{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "pd.options.mode.chained_assignment = None\n",
    "import re\n",
    "from tqdm import tqdm\n",
    "from IPython.display import Image, display\n",
    "from datetime import date, timedelta\n",
    "import numpy as np\n",
    "from sklearn import preprocessing\n",
    "from graph_utils import build_graph\n",
    "\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "\n",
    "def build_area_seqs(target_area, nks, start='2016-08-01', end='2017-01-01'):\n",
    "    # 整合到一个文件中\n",
    "    area_df = pd.DataFrame()\n",
    "    for name in target_area.parking_name:\n",
    "        file_name = 'generated/data/seqs/'+name+'_seq.csv'\n",
    "        file_df = pd.read_csv(file_name)\n",
    "        file_df['parking'] = nks[name]\n",
    "        cols = file_df.columns.tolist()\n",
    "        cols = [cols[0], cols[2], cols[1]]\n",
    "        file_df = file_df[cols]\n",
    "        if len(area_df)>0:\n",
    "            area_df = pd.concat([area_df, file_df])\n",
    "        else:\n",
    "            area_df = file_df\n",
    "\n",
    "    out_bound_indexes = area_df[(area_df['date'] < start) | (area_df['date'] >= end)].index \n",
    "    area_df.drop(out_bound_indexes, inplace = True) \n",
    "    return area_df.pivot_table('occupy', ['date'], 'parking')\n",
    "\n",
    "\n",
    "def get_nodes_features(area_df):\n",
    "    node_f = area_df[['total_space','monthly_fee','building_type']]\n",
    "    node_f.loc[:,['total_space', 'monthly_fee']] = min_max_scaler.fit_transform(node_f[['total_space', 'monthly_fee']])\n",
    "    building_type_oneHot = pd.get_dummies(node_f['building_type'])\n",
    "    node_f = node_f.drop('building_type',axis = 1)\n",
    "    node_f = node_f.join(building_type_oneHot)\n",
    "    return node_f\n",
    "\n",
    "def max_min_scale(raw):\n",
    "    raw[raw.columns.values] = min_max_scaler.fit_transform(raw[raw.columns.values])\n",
    "    return raw\n",
    "\n",
    "def init_data(target_park = '宝琳珠宝交易中心', start='2016-06-02', end='2016-07-07', graph_nodes_max_dis = 0.5):\n",
    "    basic_info_df = pd.read_csv('generated/data/parkings_info.csv')\n",
    "    basic_info_df['lat_long'] = list(zip(basic_info_df['latitude'], basic_info_df['longitude']))\n",
    "    target_area, adj, target_map, nks, kns = build_graph(basic_info_df, target_park, max_dis=graph_nodes_max_dis)\n",
    "    # target_park_basic_info = basic_info_df.loc[basic_info_df.parking_name == target_park].iloc[0]\n",
    "    key = nks[target_park]\n",
    "    node_f = get_nodes_features(target_area)\n",
    "    seqs_raw = build_area_seqs(target_area, nks, start, end)\n",
    "    seqs_normal = seqs_raw.fillna(0)\n",
    "    seqs_normal = max_min_scale(seqs_normal)\n",
    "    return seqs_normal, adj, node_f, key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using local port 18964\n",
      "INFO:tensorflow:Using local port 17523\n",
      "INFO:tensorflow:Using local port 18662\n",
      "INFO:tensorflow:Using local port 18246\n",
      "INFO:tensorflow:Using local port 17177\n",
      "INFO:tensorflow:Using local port 20852\n",
      "INFO:tensorflow:Using local port 21508\n",
      "INFO:tensorflow:Using local port 23418\n",
      "INFO:tensorflow:Using local port 17338\n",
      "INFO:tensorflow:Using local port 22999\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from abc import ABC\n",
    "from tensorflow.keras.regularizers import l2\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dropout, GRU, Flatten, Dense, LeakyReLU\n",
    "from spektral.layers import GraphConv\n",
    "\n",
    "l2_reg = 5e-4 / 2  # L2 regularization rate\n",
    "base=16\n",
    "\n",
    "class Generator(Model, ABC):\n",
    "\n",
    "    def __init__(self, adj, nodes_features):\n",
    "        super(Generator, self).__init__()\n",
    "        self.adj = adj\n",
    "        self.nodes_features = nodes_features\n",
    "\n",
    "        self.dropout = Dropout(dropout)\n",
    "        if use_gcn:\n",
    "            self.graph_conv_1 = GraphConv(2*base,\n",
    "                                          activation='elu',\n",
    "                                          kernel_regularizer=l2(l2_reg),\n",
    "                                          use_bias=False)\n",
    "            self.graph_conv_2 = GraphConv(base,\n",
    "                                          activation='elu',\n",
    "                                          kernel_regularizer=l2(l2_reg),\n",
    "                                          use_bias=False)\n",
    "        else:\n",
    "            self.dense_0 = Dense(4*base, activation='relu')\n",
    "            \n",
    "        self.dense_1 = Dense(4*base, activation='relu')\n",
    "        self.dense_2 = Dense(8*base, activation='relu')\n",
    "        self.gru = GRU(2*base, return_sequences=True)\n",
    "        self.final_dense = Dense(1, activation='tanh')\n",
    "\n",
    "    def call(self, seq, training=True):\n",
    "        s = tf.convert_to_tensor(seq)  # S*N\n",
    "        \n",
    "        if use_gcn:\n",
    "            f = tf.convert_to_tensor(self.nodes_features)  # N*F\n",
    "            g = tf.convert_to_tensor(self.adj)  # N*N\n",
    "            c = self.graph_conv_1([f, g])  # N*Cov1\n",
    "            c = self.graph_conv_2([c, g])  # N*Cov2\n",
    "            s = tf.matmul(s, c)  # S*N x N*Cov2\n",
    "        else:    \n",
    "            s = self.dense_0(s)  # S*D1\n",
    "            s = self.dropout(s, training=training)\n",
    "\n",
    "        fc = self.dense_1(s)  # S*D1\n",
    "        fc = self.dropout(fc, training=training)\n",
    "        fc = self.dense_2(fc)  # S*D2\n",
    "        fc = self.dropout(fc, training=training)\n",
    "\n",
    "        fc = tf.expand_dims(fc, axis=0) \n",
    "        ro = self.gru(fc)\n",
    "        ro = tf.squeeze(ro, axis=0)  # S*R\n",
    "        return self.final_dense(ro)  # S*1\n",
    "\n",
    "\n",
    "class Discriminator(Model, ABC):\n",
    "\n",
    "    def __init__(self, adj, nodes_features):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.adj = adj\n",
    "        self.nodes_features = nodes_features\n",
    "\n",
    "        self.dropout = Dropout(dropout)\n",
    "        if use_gcn:\n",
    "            self.graph_conv_1 = GraphConv(2*base,\n",
    "                                          activation='elu',\n",
    "                                          kernel_regularizer=l2(l2_reg),\n",
    "                                          use_bias=False)\n",
    "            self.graph_conv_2 = GraphConv(base,\n",
    "                                          activation='elu',\n",
    "                                          kernel_regularizer=l2(l2_reg),\n",
    "                                          use_bias=False)\n",
    "        else:\n",
    "            self.dense_0 = Dense(4*base, activation='relu')\n",
    "            \n",
    "        self.dense_1 = Dense(4*base, activation='relu')\n",
    "        self.dense_2 = Dense(8*base, activation='relu')\n",
    "        self.gru = GRU(2*base, return_sequences=True)\n",
    "        self.final_dense = Dense(1, activation='tanh')\n",
    "\n",
    "    def call(self, seq, training=True):\n",
    "        s = tf.convert_to_tensor(seq)  # S*N\n",
    "        \n",
    "        if use_gcn:\n",
    "            f = tf.convert_to_tensor(self.nodes_features)  # N*F\n",
    "            g = tf.convert_to_tensor(self.adj)  # N*N\n",
    "            c = self.graph_conv_1([f, g])  # N*Cov1\n",
    "            c = self.graph_conv_2([c, g])  # N*Cov2\n",
    "            s = tf.matmul(s, c)  # S*N x N*Cov2\n",
    "        else:    \n",
    "            s = self.dense_0(s)  # S*D1\n",
    "            s = self.dropout(s, training=training)\n",
    "            \n",
    "        fc = self.dense_1(s)  # S*D1\n",
    "        fc = self.dropout(fc, training=training)\n",
    "        fc = self.dense_2(fc)  # S*D2\n",
    "        fc = self.dropout(fc, training=training)\n",
    "\n",
    "        fc = tf.expand_dims(fc, axis=0)\n",
    "        ro = self.gru(fc)\n",
    "        ro = tf.squeeze(ro, axis=0)  # S*R\n",
    "        return self.final_dense(ro)  # S*1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from spektral.utils import normalized_laplacian\n",
    "# from model import Generator, Discriminator\n",
    "import time\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "class Train:\n",
    "    def __init__(self, seqs, adj, nodes_features, epochs, key):\n",
    "        self.epochs = epochs\n",
    "        self.seqs = seqs.astype('float32')\n",
    "        self.key = key\n",
    "\n",
    "        self.gen_optimizer = Adam(lr, adam_beta_1)\n",
    "        self.desc_optimizer = Adam(lr, adam_beta_1)\n",
    "\n",
    "        self.adj = normalized_laplacian(adj.astype('float32'))\n",
    "        self.nodes_features = nodes_features.astype('float32')\n",
    "        self.generator = Generator(self.adj, self.nodes_features)\n",
    "        self.discriminator = Discriminator(self.adj, self.nodes_features)\n",
    "        self.cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
    "\n",
    "    def __call__(self, epochs=None ,save_path='generated/'):\n",
    "        save_path += str(time.time())\n",
    "        if not os.path.exists(save_path):\n",
    "            os.makedirs(save_path)\n",
    "        if epochs is None:\n",
    "            epochs = self.epochs\n",
    "            \n",
    "        time_len = self.seqs.shape[0]\n",
    "        num_nodes = self.seqs.shape[1]\n",
    "        total_batch = int(time_len / batch_size)  # 2976/96=31\n",
    "\n",
    "        time_consumed_total = 0.\n",
    "        for epoch in range(1, epochs + 1):\n",
    "            start = time.time()\n",
    "            total_gen_loss = 0\n",
    "            total_disc_loss = 0\n",
    "\n",
    "            for week in range(0, total_batch):\n",
    "                current_seqs = self.seqs[week*batch_size:week*batch_size + batch_size]\n",
    "                seqs_noised = current_seqs.copy()\n",
    "                max_s = current_seqs[self.key].max()\n",
    "                seqs_noised[self.key] = np.random.normal(max_s / 2.0, max_s / 10.0,\n",
    "                                                         size=(current_seqs.shape[0])).astype('float32')\n",
    "                # current_seqs.plot(figsize=(20,5))\n",
    "                # seqs_noised.plot(figsize=(20,5))\n",
    "                gen_loss, disc_loss = self.train_step(current_seqs, seqs_noised)\n",
    "                total_gen_loss += gen_loss\n",
    "                total_disc_loss += disc_loss\n",
    "\n",
    "            time_consumed = time.time() - start\n",
    "            time_consumed_total += time_consumed\n",
    "            time_consumed_agv = time_consumed_total / epoch\n",
    "            epochs_last = epochs - epoch\n",
    "            estimate_time_last = epochs_last * time_consumed_agv\n",
    "            print('epoch {}({})/{}({}) - gen_loss = {}, disc_loss = {}, estimated to finish: {}'\n",
    "              .format(epoch, round(time.time() - start, 2),\n",
    "                      epochs, round(time_consumed_total, 2),\n",
    "                      round(float(total_gen_loss / total_batch), 5),\n",
    "                      round(float(total_disc_loss / total_batch), 5),\n",
    "                      round(estimate_time_last, 2)))\n",
    "            \n",
    "            if epoch % save_week_interval == 0:\n",
    "                self.compare_plot('week_'+str(epoch), save_path, int(total_batch/2)*7)\n",
    "            if epoch % save_all_interval == 0:\n",
    "                self.compare_plot('all_'+str(epoch), save_path, 0, total_batch) \n",
    "        self.save_model(save_path, time_consumed_total)\n",
    "\n",
    "    @tf.function\n",
    "    def train_step(self, seqs, seqs_noised):\n",
    "        with tf.GradientTape(persistent=True) as tape:\n",
    "            real_output = self.discriminator(seqs)  # 评价高\n",
    "            generated = self.generator(seqs_noised)\n",
    "            left = tf.slice(seqs, [0, 0], [batch_size, self.key])\n",
    "            right = tf.slice(seqs, [0, self.key + 1], [batch_size, -1])\n",
    "            combined = tf.concat([left, generated, right], 1)\n",
    "            generated_output = self.discriminator(combined)  # 初始评价低\n",
    "\n",
    "            loss_g = self.generator_loss(self.cross_entropy, generated_output)\n",
    "            loss_d = self.discriminator_loss(self.cross_entropy, real_output, generated_output)\n",
    "\n",
    "        grad_gen = tape.gradient(loss_g, self.generator.trainable_variables)\n",
    "        grad_disc = tape.gradient(loss_d, self.discriminator.trainable_variables)\n",
    "\n",
    "        self.gen_optimizer.apply_gradients(zip(grad_gen, self.generator.trainable_variables))\n",
    "        self.desc_optimizer.apply_gradients(zip(grad_disc, self.discriminator.trainable_variables))\n",
    "\n",
    "        return loss_g, loss_d\n",
    "\n",
    "    def generate(self, real_seqs):\n",
    "        seqs_replace = real_seqs.copy()\n",
    "        max_s = seqs_replace[self.key].max()\n",
    "        seqs_replace[self.key] = np.random.normal(max_s / 2.0, max_s / 10.0, size=(seqs_replace.shape[0])).astype(\n",
    "            'float32')\n",
    "        gen_data = self.generator(seqs_replace, training=False)\n",
    "        return pd.DataFrame(gen_data.numpy())\n",
    "    \n",
    "    @staticmethod\n",
    "    def discriminator_loss(loss_object, real_output, fake_output):\n",
    "        real_loss = loss_object(tf.ones_like(real_output), real_output)\n",
    "        fake_loss = loss_object(tf.zeros_like(fake_output), fake_output)\n",
    "        total_loss = real_loss + fake_loss\n",
    "        return total_loss\n",
    "\n",
    "    @staticmethod\n",
    "    def generator_loss(loss_object, fake_output):\n",
    "        return loss_object(tf.ones_like(fake_output), fake_output)\n",
    "    \n",
    "    def compare_plot(self, name, save_path, start_day=0, week=1):\n",
    "        fig, ax = subplots()\n",
    "        fig.set_figheight(8)\n",
    "        fig.set_figwidth(20)\n",
    "        real_seqs = self.seqs[start_day:start_day+batch_size*week]\n",
    "        generated_seqs = []\n",
    "        for w in range(week):\n",
    "            generated_seq = self.generate(real_seqs[start_day*w:start_day*w+batch_size])\n",
    "            if len(generated_seqs) == 0:\n",
    "                generated_seqs = generated_seq\n",
    "            else:\n",
    "                generated_seqs =  generated_seqs.append(generated_seq, ignore_index=True)\n",
    "        generated_seqs = max_min_scale(generated_seqs)\n",
    "        all_seqs = pd.concat([pd.DataFrame(real_seqs[self.key].values), generated_seqs], axis=1)\n",
    "        all_seqs.plot(ax=ax)\n",
    "        n=2\n",
    "        ax.legend(['real'+str(w) for w in range(1,n)]+['gen'+str(w) for w in range(1,n)]);\n",
    "        fig.savefig(save_path+\"/compare_\" + name + \".png\")\n",
    "        plt.close()\n",
    "    \n",
    "    def load_model(self, save_path):\n",
    "        \"\"\"\n",
    "        ...\n",
    "        \"\"\"\n",
    "        self.generator.load_weights(save_path + '/model_generator_weight')\n",
    "        self.discriminator.load_weights(save_path + '/model_discriminator_weight')\n",
    "        print('models from ' + save_path + ' recovered. ')\n",
    "\n",
    "    def save_model(self, save_path, time_consumed_total):\n",
    "        \"\"\"\n",
    "        ...\n",
    "        \"\"\"\n",
    "        self.generator.save_weights(save_path + '/model_generator_weight')\n",
    "        self.discriminator.save_weights(save_path + '/model_discriminator_weight')\n",
    "        print('models saved into path: ' + save_path + ', total time consumed: %s' % time_consumed_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def start_train(target_park='宝琳珠宝交易中心', start='2016-06-02', end='2016-07-07'):\n",
    "    seqs_normal, adj, node_f, key = init_data(target_park, start, end)\n",
    "    seqs_normal[2].plot(figsize=(20,10))\n",
    "    # seqs_normal.plot(figsize=(30,15))\n",
    "    name=target_park+'_GCN_'+str(use_gcn)\n",
    "    print('Start '+name, seqs_normal.shape, key)\n",
    "    save_path='generated/'+str(epochs)\n",
    "    #train = Train(seqs_normal, adj, node_f, epochs, key)\n",
    "    #train(epochs, save_path+'/'+name+'_')\n",
    "    #print('Finished '+name)\n",
    "    #return train\n",
    "\n",
    "def resume_train(train, epochs=1000):\n",
    "    name='Resume_GCN_'+str(use_gcn)\n",
    "    save_path='generated/'+str(epochs)\n",
    "    train(epochs, save_path+'/'+name+'_')\n",
    "    print('Finished '+name)\n",
    "    return train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 96*7\n",
    "lr = 0.0001\n",
    "adam_beta_1 = 0.5\n",
    "epochs=10000\n",
    "save_week_interval = 10\n",
    "save_all_interval = 50\n",
    "dropout = 0.5\n",
    "alpha = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start 宝琳珠宝交易中心_GCN_False (4032, 3) 1\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAAJNCAYAAACmzGU0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZgkV3nu+UZERlZmVXV1VfWqVktqtSS0AQJJ7BI7BmzAvsZwL7axwSsztq+f8WNjj4exfQff4RoueMCAGcxyr22MbcY7AgntErIWWkJCQlIvakndLfVS3ZXVteQS25k/Ik9kZMZacb6sqqj6fs+jp6sySycjYznLd97v/TQhBBiGYRiGYRiGYRiGYZj1jb7aB8AwDMMwDMMwDMMwDMMMHw4CMQzDMAzDMAzDMAzDbAA4CMQwDMMwDMMwDMMwDLMB4CAQwzAMwzAMwzAMwzDMBoCDQAzDMAzDMAzDMAzDMBsADgIxDMMwDMMwDMMwDMNsACqr9cFbt24Ve/bsWa2PZxiGYRiGYRiGYRiGWXc8+OCDp4UQ2+LeW7Ug0J49e7Bv377V+niGYRiGYRiGYRiGYZh1h6Zpzya9x+lgDMMwDMMwDMMwDMMwGwAOAjEMwzAMwzAMwzAMw2wAOAjEMAzDMAzDMAzDMAyzAeAgEMMwDMMwDMMwDMMwzAaAg0AMwzAMwzAMwzAMwzAbAA4CMQzDMAzDMAzDMAzDbAA4CMQwDMMwDMMwDMMwDLMB4CAQwzAMwzAMwzAMwzDMBoCDQAzDMAzDMAzDMAzDMBsADgIxDMMwDMMwDMMwDMNsADgIxDAMwzAMwzAMwzAMswHgIBDDMAzDMAzDMAzDMMwGgINADMMwDMMwDMMwDMMwGwAOAjEMwzAMwzAMwzAMw2wAOAjEMAzDMAzDMAzDMAyzAeAgEMMwDMMwDMMwDMMwzAaAg0AMwzAMwzAMwzAMwzAbAA4CMQzDMAzDMAzDMAzDbAA4CMQwDMMwDMMwDMMwDLMByAwCaZr2FU3TTmma9ljC+5qmaZ/RNO2Qpmk/0DTtavrDZBiGYRiGYRiGYRiGYVTIowT6HwDelvL+2wFc0v3vVwD8ufphMQzDMAzDMAzDMAzDMJRkBoGEEHcBmE35kx8H8JfC5z4Ak5qmnUN1gAzDMAzDMAzDMAzDMIw6FJ5A5wI4Gvr9WPc1hmEYhmGYVeOT39mP3/zb76/2YTDMqvC52w/hRX90E37lL/dBCLHah8MwDMOsESiCQFrMa7EjjaZpv6Jp2j5N0/bNzMwQfDTDMAzDMEw8f3bbIfzLw8+v9mEwzKrwiZv2Y6Ht4DuPn0TLdlf7cBiGYZg1AkUQ6BiA80K/7wYQO+MSQnxRCHGtEOLabdu2EXw0wzAMwzBMOo7rrfYhMMyqMrtkrfYhMAzDMGuECkEb/wrg1zVN+1sArwBwVghxnKBdhmEYhmGY3Agh8Pk7nsJ9h8/g/OnR4PW242HcoNj3YphycPDkQt/vjSUbu6dW6WAYhmGYNUVmEEjTtK8DeD2ArZqmHQPwhwBMABBCfAHAtwD8KIBDAJoAPjisg2UYhmEYhkliZqGDT9y0HwCghZLVW5aL8RGKfS+GKQd/v+9o3++zTVYCMQzDMD6ZMyIhxPsy3hcAfo3siBiGYRiGYQoQXuhesn0cB04uAgDa7IfCbDBml2ycO1nHX/7iy/GmT96JBqeDMQzDMF1YG80wDMMwzLrg8MxS8POmmhn8zKa4zEaj0bQwNWZierQKAHj0ubOrfEQMwzDMWoGDQAzDMAzDrAtue/JU8PObLt8e/LzYcVbjcBhm1ZhdsjA1WsXmuh8Mvf/pM6t8RAzDMMxagRPkGYZhGIZZF7RsF1vHR/DN37gOOyZGcNXuSfzMl+7H2aa92ofGMCtKo2nh/OlR6LqG6y7eiuNnW6t9SAzDMMwagZVADMMwDMOsCxpLFvZsGcXOzTVomobdU3UAXB6b2TgIITC7ZGF2ycL0mJ8KdsGWUcxxIJRhGIbpwkEghmEYhmHWBbNLFiZHe15Ak10/lAZXRmI2CF+95xlc/dGbsdB2sHXcv/+nRqtoNC34tVwYhmGYjQ6ngzEMwzAMsy5o2S7GQqXgRyr+Xpfleqt1SAyzohw8tYhNtQp+7+2X4UdfeA4AoGbq8IT/HIxUjFU+QoZhGGa14SAQwzAMwzDrgpblom72FrkVXQMAuC4rIJiNQWPJwjmba/iZV1wQvFbtBkNtV2CEZ/4MwzAbHk4HYxiGYRgifuvvHsaL/vAmvPlTd+JT39m/2oez4WjZLmqhIJDRDQI5HgeBmPWP5wnc+MMTQRqkpGp0FXFOeRRxX73nabzlU3fixseOr/ahMAzDrDs4CMQwDMMwBNiuh3/8/nNY6Dg4dGoRNzzKi5eVpm27qFd7QSBN02DoGlwOAjEbAOl9tWOi1ve6GSiByhMEuumHJ3Dw1CLu2D+z2ofCMAyz7uAgEMMwDMMQMGg+3OBqPCuK43qwXYFRs9/zxNA1VgIxGwLZB7358u19r5dRCdRY8vtPruzHMAxDDweBGIZhmGXx70+dxus+cTs+f8chrjYTQi5aAGDv1jHMLln4NquBVoyHjswBQJ8SCPB9gVyvPItfhinKvmcaABCUhpdIT6BOSYJAluNh/8kFAMAjx+bwudt5rGEYhqGEg0AMwzDMsvil/7kPz55p4uM37sfpRd6llYR3rH/+1XsAAJ+8+cAqHc3G458ffg4AcOWuzX2vsxKI2SgcOrUIALh0x6a+16USqCzpYI8+Nxf8vNRx8Ymb9mNmsbOKR8QwDLO+4CAQwzAMsyyalhv8PJgCtZGR5+Lbv3k9fv7Ve/C+l5+POU4JWzFsx8M5m2t41UVb+l6vsCcQs0GwXA9Toya2D3gCSSVQWdLBZruqyn/79evwJ+9+MYB+pSXDMAyjBgeBmFgOnVrAQpsHXIZh+jl+ttX3+4PPNlbpSNYedx/0DUxlKsb0mInTix3McaBsRbBcL1jshjF0nZVACZxt2XhqZnG1D4MhomN7GKkYkdfNkimBnjg+DwCYGjMxNWYCAJ4+zfcpwzAMFRwEYmJ586fuwvv+4r7VPgyGYdYYf/gvP+z7/fN3HFqlI1l7fP2BowCAqW555gumxwAAn72Nz9FKYLtesNgNU9E1uC4HgeJ47xfuxZs+eedqHwZDRMdxMWJGn4GyKYHufeoMAGDr+AjOmxoFANz6xKnVPCSGYZh1BQeBmAhSNv/Yc/OrfCQMw6w1Ti50sGfLKB7+g7fgjZdtRyuUGraRkTvsH3zNnmDB9Z5rd6Nm6jjNXhYrguV4gfdJGPYESkaa75YlOMCk03E8jMSo4QJj6JIogTQNeMGOcdRMA+dNj2LLWBUtm8cahmEYKjgIxEToODzQMgwTz3ONJl5y3iQmR6u4/JxNaDRtrtoCBAuUcyfrwWuapuHSnROYJfYFclwPZxY73FcP0HHi08EqBlcHy4JTFtcHfhAomg4WGEOXJNjXcTxs39TzNbpgyyj7zzEMwxDCQSAmQnhnn3cHGYaR/NP3j+H0ooXpsREAftqT6wnMt51VPrLVp93tN2tm/wJsatREY4l28fKrf/UgrvnjW3DpR27kdLwQtstKoKLM8gJ7XdBx3FQlkFUSJdDg95garQZm0QzDMIw6HARiIoQlt7PEixeGYcrLwZO+Meevvm4vAASTdA4W9/rN+kAQaGykgqZFGyQ7cGoh+Jn9hnpYSUogrg6WCY/164OOHf8MlM0YumN7fd5GYyMVtIj7UYZhmI0MB4GYCG0OAjEME0OjaWHr+Ah2dMsPG7o/hPACOxQEqvYHgeqmgbZNu/AKl0pusidTAFcHKw6X314fZHkClSVgP5jWVjcN9gRiGIYhhINATISW1Zsk3PLEyVU8kuI8cXweH/zqA30BLWblODXfxk9+/h7csZ+reawnZpcsTHfL9QK+1woAOOy3EqTR1gYq81AuXlxP4P1fvh+Lnf4d8TNsPA0AsB0Bs3tPhqnoGpySKCBWght+cBw/8qd3Ys/v3RC8xn4r6wM/jSrZE6g8QaD+dLB61eAiBAzDMIRwEIiJMN/u7QienG+v4pEU5/f/6VHcvn8GP3yeK5ytBo89fxYPHZnD/3vn4dU+FIaQxpIdlD8H/MU1ADhcfjvwRZqomX2vUy5eZhY6uPvgaVQNHf/4v746eP3JEwsp/9fGoe24EU8mANB1DSwE6nHXgRk8e6bZ9xq1bxWzOnQcL75EvAwClaSvHjR5rw1BUckwDLOR4SAQEyGcAlbW3UFZrIh3f1cHaeBYFhNKJh+NpoXpsV4QyJBBIF5hB4voqdD5AfzFS8t2SSqoyb75M+97Ca4+fwo3/2+v7Xt9o9O23YgnEwDoGuBxBbuAtuNiV6iK3aaRChtDrxM69jpJBxv4HqNVA5brceoxwzAMEZXVPgBm7WC7Hr7y3aeDhd3erWOlW1ycnG/j4zfux8NH5wAAcy32OVgNvvLdpwEADz7bWOUjYah4fq6Fg6cW8bILp4PXpNkop4P1AubTo/1BIBmU6DherEolL0IIfPymJwEgUGPJgFPZgvVt28Wnbz2I/ScW8Kq9W/DLr91L0m7LSlACaRo4BtRj8DxNjtFXsGNWh6R0MJkmWQZjaCFE5HvIfrRtuxgb4aULwzCMKtyTMgH/8OAxfOzbTwa/n79lFCfny+U18bX7nsU/PHQs+J0ntitP23bx+PFeGl7TcjBa5a6m7PzyX+4DAHihnViD08EC5lvddLD6QDpYNzUjKUCRl5nFDu7YPwMAuHj7OABgsvtZZQvWP3SkgT+/4ykAwG1PnsJ7X3YeNg+ctyK0bS9izA2wEmiQlu2iZur4sRefgwumR3HH/hkstLny0nogyRi6YujQtXIogRxPwBPo+x4yxY2DQAzDMDRwOhgTYIcWdxO1CsZHKuiUzFh5sdN/vCxxX3nmmr766qrdmwEAjSarsdYDxxotAL3AD9DbXWaJvr+wrlb0vvMD9KqFqZpDy+pNn/vpq7FlfASAv7CbqFWCZ64sDFaiogjWO64Hy/Vi08E0TeMgUAiZNve5n74aH37bZTANrW/8Z8qLleAJBPgpYWVI0e50A1Xh78GpxwzDMLRwEKhkdBwXdx6YQcehD86EJ8/TY9VSluQ8eKpnkFoz9dItjsrOQtvGtx49DgDYu81XK7Aaa30gd5C1UIxDlojndLBkPxqp/lHtS6XaZ2q0XzEzPVYlVwLNLll45OgcjgyYB1Ow2HHwt9870vfas7Pqn9Pu3p+D1dkAqQRS/oh1Q2vgXq0YOvvnrQMc14Pjidh0MMBP3y2DEkhuPoa/h9kda8qQzsYwDFMGOAhUMr6x7xh+/isP4P978Fj2Hy+T8Ab2edOjflWbkgWBvn/E9wI6f3oU06P0iyMmna/e8wz+r28+DgB4cVcJxNdgfXDFrgkAwPWXbAteMzkdLKBlZQSBFCuESd+fQePpzaNVcu+z13/idvz45+7Baz9xO2m7APBX9z6Luw+e7nvtlsdPKrcrz2+sEggaiTH3eqFluaiF0uYqusbP8DpAKmiqMelggJ9eVSolUOh7VAweaxiGYSjhIFDJONud7MvUDEpk+c3/+Qsvxxd+9hpfCURU2nilcDwPb7tyJ775n6/D1FiVVSgrzIn5NqZGTdz94TcEwYKymdYy8Vx+ziaYhoa3XrkzeI0l+j1athvrRxM2NFUhMJ4eCAKNVHRYxMrQ+SH6w5ycbwMA9n3kzbj3f38j6qaBJsE4I89vfIl4VgKFadv9aXOmocNmNV/pkc/AaEw/BHSvcwmUQFZMOliFixAwDMOQwkGgkiFTMY7Ptch3NuUE4iW7JzE2UkHNNNBxvD4j2LWMEAK2K3Dx9nFM1ExMjVbZE2iFOXm2ja3jIzhvejRYrHIgbn1gOR62jI30vRbszpakjxgmLduNNWSl8wTyn6PJgXQwPwg0vIXRibNt0rHm5HwbF2wZxdbxEZyzuY6Lto+RBIrl+BVvDM1KoDDRdDBWAq0HWimBUKCEnkB96WCyuhnfpwzDMBRwEKhkSLXOPz/8PD5+037StoMJRNW/LagWLyuF7Qq4ngiOe3KUy96uJJ4ncOuTp4JdyM11E5oGzLIv07qgE2M4Wun6NLi8O+ung6UqgYqfo4W2jf/+nQMAEPH7MA3ahd2Zxf6KkK/82K34kxtpxhohBL792AlsqvWq+0wRpe3KcSrZGFr5I9YNg/dqRdfZa2Ud0E55BgCgWhJPoFuf9NNDB32rAE4HYxiGoYKDQCUjnFJw8OQiadtzTQt10wgWGbL88Fliv4lhMbgLVu8qmZiVQZ7rS3ZsAuCnCm2ucyBuvWA5HqpG/5Bh8O5swFzLCvrMMBTG0DKFKo6qocN26M7/0W6q8YVbx/Brb7gIuzbXcChkuK/CYsdPM7vynM3Ba1OjVRIlUJonkK6BlUBdhBDdEvHhdDCNK/ytA1qWPwYnBYFMoxzBvoVuOuqrL94SvCZVp5y2yDAMQ0Ml+0+YtUTLcjE1auLycybIvVZml+w+v4nJ0Wr3dQu7JuuknzUMBnfBKobOi9MVRFasu7JrIAwA00QLPGb1sRwvYjhqGlIJxM9ZY8nGC7oB0DBScdFW8L1J8+gxiVM8ZND2k++9ClefP4WHj86RmbvL0vAvu3A6eG2ayLutp2SNTwfjW9RHBusj1cH4BJWeVkpKJOCng5VhY6yxZGHbppHY6mCsBGIYhqGBlUAl418efg4jFQNTQygL/A8PHevzmwg8XQgX8a4n8MGvPoC3f/pu7HtmlqxdoLcTLEsEVw2tFLte64W4PP6pMQ4CrRcsNxoE6imB+DlrNC1Mj1Yjr9cJlEBzKc8QdYqHHFfkd6FK1wIQeLSFy9xPjVYx33aU76HAGDqmPLZfIp4Xj0B4s6T3LJv6cMbKpY6DD3z1ATx9eom8bSZKTw0dP7WvlkQJNLsU7Ut71cHW/vEzDMOUAQ4ClQxPAOO1CiZqlUBaT4GUyo9Ve+Iw6duwRPg5Mwsd3L5/Bk8cn8c9h86QtQsA821/l3mi5i8wyiJ9Xi907GhZ16lRE7NL5UgnZNLpxKSDVbpBoI2uBGrbLpqWGynfDtAEgWR6xB+844rIe9Rmr4Ol6DfVTCx2aHzhpOInfJ7kONNU/Iz5ln+OJupRgTN7AvWIMw8eljH0XQdmcMf+GXzsW0+Qt81EmW/1z4EGqQ7ZRJ6KRtPC1Fj/dzCDdDB+kBmGYSjgIFCJsF0Pix0H73jxOaiZhlJ6QbRtf2B93aXbgtcoFi+DhHeU6dPZ+hcYZkVn6fAKItPBwubBU6M0qR7M6mM5HkYGvCa4OphPEDiJUQLJoGhLob+W6o23vXBn5L2qoZEu7BpNC4auYaIbnKmbBjpEY8CgygigK0Awm3IN2BOoR+CdVB1MBxtecIDP/Mog+6HJmGcAKE91sEaz35oA6BUhYCUQwzAMDRwEKhFz3SpL02NV1E0DbYcuOCMnBuGd/sDQ1FIfdOeaFv7vbz2Bz9x6MHjtxsdOKLcbRk6A5OTB1DVYrseT/xUiLh1seqyKE/NtUjUZszrEK4HYpwEAHjl6FgAwPRbdgdd1DTVT7zP1Xy5ppsfVCq3icXbJxtSoCU3zA3w1UyfbCBhUGcn2AfUgUGPJQrWiB9UJw/ieQBv7HpXEKYH8dDDa8+N6An96i1/R7ubHT5KnrzNR5DkOp/WHMQ2N1ER+WDSWrEgwNzCG3uBjDcMwDBUcBCoR4XSnumnAdgXZ5F/uJIc9PyiVQHcemMEX7zqMe546jfOnRzE5auLEfJs0QCNNR6XfhDSt3egqhZVCKoHC95AMyD34bGNVjomhw3LcvlQ/oDcx3+gl4h8/Pg8AuGznROz7IxVDKQjUlma+MQEOk9gTaHABVjcNOB7NWDOoMpLtA2pKKcAfHydqveBVGDaG7hFXRrxi6OQKiyeOz+NAqILprU+cJG2fiTLfcjBWNYK5zyDVirHmlUCeJ/x0sMEgkM5FCBiGYSjhIFCJCMu4g4ozRDu0coIfnjzUqjrZZ8gdqrt+5w2468NvwK+9/mIAIPU1ajQt6FrIE6jCKoWVJM4T6NUXbfXfK4EPAZNOnDF0hUvEAwA6th8g27N1LPb9iq4peVnIvn8wCCfbdimD6U2rT6lDla4FSJVRtS9QUyPabGhZbqwKCAA0NoYOCMqIV/s9gai9VqTq66sfeFnf78zwaNku6tXkor8mceroMJhv2/AEIv5q3aEGgpMLGYZhSOAgUIkI7+BRTZwlxxpNAP0qjqqhQ9dogkA/OOanS0zU/QCNHOAbhKbBs90dbL07W5AL1LW+87Ve6KWDhe6h7s9s0F1+LMeLBCGMIRpDP3x0DncdmClFOqe/+IoPQADSeLf4M9C2XdRMPVblYug6hPB30CkYrHImxxoKDzpfZdSfqiIVKarjTMt2Y9PlAF8JVILbaEVoxSiBTJ1WCfTkiXncuX8GAHDedB2moXGBgCEjhMD3nplFvZo8rR8pgSdQI7A96O8nZN9HNdYIIfBod17KMAyzEeEgUIkIJm9VI9jxVK2oInn3n98LoFeBAfAH3ZppKMv0AeB73XLwctEoFwKzhLuDgzvYHIBYWQJj6JAnkLyf1vruI5ON5USVQMNKuWzbLn7ic/fg577yAB4pwUS9ZSUHIAA/lUHlHKUFOKjNuWeX7L7KPEEQyFZ/hmcH+uj+9lWDQB5qCYE4LhHfo2n56tvB6mAeYSDx5778AL703adRNXRsn6hhc72KOVYCDZW/eeAIDp1axNHZVuLfVIlTR4dBUOBjIB1Mzh2pHuO/33cU7/zsd3H7k6doGmQYhikZHAQqEXISXjeNYICkllhHPD90jWRxIQTw5su3B78HSiDC459d6t/BDhaoGzxVZaUIlEBmVAm01ieeTDZxxtByYk7tJxI2kT053yZtexikBWkAPxiq0g+lBZl0wh1yIQTmBvw4pKKSIuWsMdBHA3SGr23LRd2Mn9KwMXQPWa0xXH1JjpU2kbfXXMvGe6/djbt/9w2YqJkYGzFIq4wyUQ6dWsz8G9OgNZEfBo2EIJBMB6N6jp+aWQIA7D+5QNIewzBM2eAgUIlY6BpD10xjKEEUABFDwYqhkywuOo6LHRO14He5EKAsH94Y2MHu+ZWs7UnPeiHOEygIAvE1KD1xSiD5jFErgY7ONoOfzyyufQVB2/b6lBWDqJbgbtluosqldw3Un7GFjgPHE30BAl2nM/8+tdCJKIF6ajK19tMCcZqmYYN7lwfMNm1oGrC5Hh0rKTZMXE/AcjzsmqwHY37dVDNGZ7JJ8sMKU62UQAnUjAYpgV6wm2qokf31mcUOGksWGksWmRKOYRimDHAQqER85J8fAwBsqlVCQRT1PPuw58agr4VBpAQa3MmWuzyUZWNnB3awOQCxssSlg0nlyFqfeDLpeJ6A44lIEEjTtG4fQXd9v/Ldp/Efv3hf8PvfPPAsWdvDomU76Z5AiiW42ykBDqnGorgEsoLTRChAYARKI7W2D51axNmWHVmsUgUg0nyZdA2l8JZaCeaaFjbXzeC+AfwgJUATBIqrPlYzDbQI0gmZZEa7htBjKf2QafhpqWs52BEogQaCQBqxEkj2Q39x99N46Udvxks/ejN++xuPkLTNMAxTBjgIVCIMXcP506PYMVHDZFfxQqEEWuhW6Lps5ya8bM9033sVXVPeARZCRCbooyM0ZYHDnzE34DfB6WArS2o6GAfiSo28fuEAn4QqZVRy4OQCJmoV/Pf3XIWt4yPQEDVDXmvMNW1M1s3E903FEtz5PIEISrh3NxWuu3hr8BqV+feJs35a37UXTPW9HqQiKfYRLctNVGNxifgeg2nTQM+7jSIdLOxdKKmbBomxOJOMDKZ+/Vdemfg3ZRiPG00bVUOPBLOkEogqmCuD27/z1kvxR++8Apfu2IQDpzg1jGGYjQMHgUqE5Xh4+4t2AgA2jVRQ0TUSJc1cd+L/S9fvjaSDUSiBLNeDJ/qNKE1Dh2loZD4Bix0Htiv6JrecDrayxFYHkws8VgKVGnltB5VAQDdQTBhonV2ysGuyjp+6Zjdee8lWUrXgsGgsWZgcWFiHqRhq/WjLSla5UFZok/1xOBWDqn0ZYNixudb3OpWxdcdJ8U3S2RhaMlhAAfCNywGaDRO5sRMe7+tV9gQaNvL8vnDX5sS/GSlDEGjJwtSYGamESJ0OJs/Xr752Lz7wmgtx5bkTpNVqGYZh1jqV1T4AJh+eJ9BxvGCSq2kapsaqJEqgOw/6pVwHS/cCUgmkatjpTzgGd2l9iTjNxPC+w371scnQdzCHWB3sS3cfxg2PHsfnfvpq7Jqsk7dfRr792HEA6DMPNnQNmra2J50ryfNzLbz6v90GwFfejVYNfOH912D7plrG/7m6yFS/uCAQVcqopNG0gueYqo8b5KPffBz3HDqNqdEqvvKBl6WmcuXBT0VNUQLpxQ1ZHdfDQ0fm8ObLd8S+T+nL1LZdaFp/IFc+zqrG0DLAYOqDvlIyAKGuBEr1BOIYEAC/+tu5A2NWz5xbvZ/+/tE5AANBIMKxnomnZbuoVvTAwysOswSbMoNp/RL5tahKxN/wA3++IlMhp0eHM9YwDMOsVVgJVBLaTjTPfqxqoEkgsT4ZyPSnI+9RLPDijl3+TmUW+dSMXxnjmlCqQaBCGUI62KdvOYjvH5nDD47NkbddVhxXoGbqfTt4mqZ1F8C8AgOAh4/27pep0SoeOjKHHz43v4pHlA/p6TRixCiBiMzjJY2mHShRNtUqaFouuYfFN3/wPJ4+vYR7D5/B06eXlNoSQqBtexgbSd5TqShUBzvdNcaeqMe3b3SDKCRKoG4gJfwMU7Uvgzwy4CAxCaqDxaUch2FPoB6NJQvTY/0BS5NIjQX0TN1fet5k8FoZDInLjuV4sf1zmFKkgy0lBIF02nQw2/OwqdbrU0dH/LGG+wmGYTYKHAQqCXES64qh08i3bRfjIxVsjlUC6cqpHvLY69X+261eNcg8gRpLFkYqOi7cOha8Nsx0MJnaMMvy4YBG08K7rtoVed0g8JVaL4R3Gv/bu18EgNYcfVhYKelgukZTPlwSXgTIwLEMJFPRslzs3Tbuf57i7q8MXphG8g58xSvREyoAACAASURBVNBhF1xgy0D59ZdsjX2fUgkU5z1kEJWgl99/8DxVCKqDxaUch+ES8T5CiFilBZUaC/D7s7GqgfOmR4PXTEPjtOwh43kiVQUEhNOz1+6zMNu0IpXBAPp0sLmm3TdfMQnTahmGYcoAB4FKQium4oZfcUZtYtW2XXz5u09jsWsOPQiFEiju2AGgVqGTiM8u+ROH8A72sNLB7j44g3a30gnLh32EEGg07YjXBCBTClfhoNYgc81e0FCeqzLcQz1j6OiQoWka2e6p5wk0QosAuainChafWmjjEzc9ifm2g3Mn/RS8v3ngiFKbMnhRSdmFN3Wt8AI7qf+U9Dx71B4y1xP42v1HItdYZm+RKYEi6WDqSqB/fOg5AFlBoMLNrxtatgvL8SL9NIUaCwCem2vhy999OuKPZRqsBh02rhDBs5SEGSiB1mZqXsdxcXhmCVNj0Q1J+dUogrmu5xcSCQebesFovk8ZhtkYcBCoJMggjayqBaibjQLAQ882Ut+vGOoqDrmIiXgCVenKxs63bUzU+icOw0oH+/QtB4OfGyVQcawEluvBcrzINQAAg+AeWi/Mt/wg0PtfeQGpufuwSVMCGZpGUp4c8J9jTyBYRMrAB1Ww+J8eeg6fu/0pAMDF2zcBAO4+MKPUpuxf0hZgplE8HSap/5RQKYEOd1NqRwfS2mTQRnXxJVWr0XQwdVPiz9zq98lX7pqIfV/T2Bga6KkOB6uDUaX8/evDzwMAXrG3P7XcDwLxGDBM3GUogTprNDXvoWf9dOnpsZHIexqhEmi+5Y8zU1xIhGGYDQwHgUqCrFrQt3OhYDYqyfIUIvEEspI8gXQyT6CW7UX8ICjNLsPMNi382IvOwbmTdcyWQMWxElgxlcEkhkZrHFxmWraLqVETH/2JF0LTNEyWxIxypdLBgkVqdye41n2mqfqJcMGZLWNV/Oc3XozFjqO0+JUKl8HKimHqVaNwSltS/ymRSiDV1GC5MPzwWy8daN//V/UZlim0g+dJrltV0sHOtmz84nUX4pV7t8S+r2saOAbUm0cMKoHkNRBQO0mNpp+W/an3vqTvdU4HGz6uJ4LUzSSqFRrF17CQY+HbX7gz8l5wjxI8yPJz+pVANP0owzBMWeAgUEmIG7RMBbNRSdYOO0V1sBPzvvH0YJCG0hi6HVMZJqiEQTz5nGvamBozMTVmshKoiwwSxC2EDYJ7aL0wWMFoeswshRIoKBEfc311nc5vRfZzEU8gIsWgHlok1aoGpsaq8ARwerFTuE0ZHBlUuISpmQZalmI6WILpsfxc1WdMpvyZg+lgcgdesX15fIOKKU3T/LFMwTOpabmxPiISnZVAABBsWgwaQ+tEvk8yLXsQk8i/kEnG9XoB4SSqht+HrFWT7rh5rqTnCaR+Hz3bNS+fikkHs1m1zDDMBoGDQCVBLhT75au60u4pkB0EolACfffQaQDA1vF+iS+lMXRcZRhZiphy1yvIJR+tYrJexVyLjaGB3jmOU4pQBBLXCy3bDdQtAPx7qLn276FA6RWjRtE1jax616DisWb69xNVOlg4DWLb+Ai2dPukmx8/WbhN2T8Olj4PoxLwzkoHk4sj1X46qQJchShVKEibi6swp+uFPZPm2/49M1GPpqJK2BjaR25aDHr2aIHfilr7c00bm2OuQ8XQYbkeV14aIp4QmUEgc0jqaCrkWBh3D/UCleqfc9sTpwAAu6fqwWsmkaKSYRimLCTXtGXWFL3JW29wrBgaWrZiCkB3gfHd331D7PsVXVdegFV0DTVTx67Jet/rNZPOGDquqo1ck1FO/oNc8rEqqhUdc621OZlaaVKVQAYHgSTtgfu0WtHRtOJN2dcSaUogQ6cz3Z0dUALJz6PauZaLn1t+67W4aNs45luOcvtJpc/D1Kt+PyqE6DOvz0MrZzqY6gLbTlICEaWD9dLmot9f5R6Si7a08tgaG0MDCCktIp5ANPdQy3YwNhKdVlZDJejTqugxxXG87CDQWjc/blkuDF2LTSunnM95XRPti7oVIoHQueEgEMMwGwQOApWERtPG+EgFI5XeQsA06JRAgyVjJRRKINsV2L6pFnmdMh2sZbmRnXKqNIYwJxf81Lbpsarvc7CGS62uJDKVJMk4eK1OOgdZaNt9Jscjpp6owCjCfMvpa8/3ylj75ybt+lKa7spgt5Tpy8+jCgJZjoeKrgWm0FI9qBKMTlO4SOqmAdcTsF0R+HLkpZ1TCaT6iFkJgT65sFQ2hg7SwWjvIRlgTlsA6xqNl0jZmVnw0x4HVVNU91Db9gL1XpjwApuwO2VCeJ5ARgwoSMVcq4UaWraLWkWPDZTLe5TiOW7ZLnZu7p+TBiopwnPjuB6WOn7/bRgaxmMCpAzDMKsF90glYa5p9amAAH9AV921kMbQaZVnisr0JZbjxe7++T4ZVGkeLurV+MULlWmtEAI/+um7Afipbaahc/54lz++4XEAvR3fMGXxBPq3R57Hb3z9+32vTdQquO/334TRqnpX6bgeHnhmFi/f06ucU5aqOWnG35SpNo2mDdPQMNYNzkhlmUV0jmzX61OrmYYGQ9eUgtEyEG+mrMDCpe7jAmlpZHkC9VJ5iJRAkXQwGr8YOygRH7/AK3r4Tq4gECuBAOBr9x/BaNWInCuqe6hl+cb3g4Sf4zo4CjQM3BxKICoT+WERl9YvoQpUAlFFLtALTlOem//4xfvwYKgC71c+cC3eeNkOsvYZhmFUYE+gkrBkOZFdBIoF5FzTxqZaJXHyMGLqyuVEO46HaiU6sFcIVEaSQcNdgM7nQDLfduAJ4IpzJvDyC6dLs4BfCe7Y75fZjrueFV0vRRDowMkF6BrwB++4An/wjivw7qt3Y77t4MTZNkn7S92A58U7ehL0stxDnW5lq2GXiG9afjqJ3AkeGYISKPwdNE1DXTEY7eRQAgXfo8C1lobStYTgEZVhaiehAhyVabDj+kqFuDLWula8falqyFICsSeQr0i7YMtY5HWqe6htRxW5QG9zoAx9XVnx08HSp/RUJvLDIun+AXrVwSie45YVDTYNo5rs/hMLeOXeafz+j14GADh4cpGsbYZhGFU4CFQSWrYXGRwrChVVJI1mfDUPCYVax3a9+NLSOk3ZXiGELyMeOD8GcTqYTFX5xesuhGnonA4Ww1In6m9DkVK4EjSaFiZHq/iF6y7EL1x3Id71kl3B6xRItckLd20OXitNOliKEkgjLBE/GMyV/QbVxNyK6YtqpprvmZ3DE0jle7RsF1VDTwwy9dIklt10H0nX2KBSAnle4ncwFCrM9dLMks+/1lUabfSUsI7j4toLpiKvU91Dcd58APutrAS+MXT638hnZK2Ox3EKHYlGqASKmy+aBu25sRwPix0Hr7loK375+r2oVvTA845hGGYtwEGgkhBXAt2vqKIaBLIT/YAAGt8ey/Fi04R0osWj5XrwRDSljcrLQvLndzwFAJjqltel8GRab1gx96OfDrb2z1Njye5LuZRpDbJilSqBwW81nI5UvCrSSmIlqEQA//pSLK5PnG3jGw8e61P9mMTG0JYjIp43qgb1eaqDye9RJAjUtl2MxPisSKh2yGUwcjAdjCoI5LgiMWVOxbhZjoFZ6WCAepCj7CSl21DdQ3GLa0Dt/mfy4Xoi2PhKwiCq9Dcs4rwdw1B4ex0/28J9h2cjY0ovHYzmHp1r9vztNE3DZN3EN/YdI2mbYRiGAg4ClYS4yRtFqlZjyYrN4ZdQBIGSlEAGkZdIu5suEU0Ho5U+H5rxpbzXnO97upiGTrY4LTvXX7IVAPCea3ZH3iuLEmih42CiFg4C+cFRqt27wNsldJ/6pZPX/rnpBCqR+BLxFM/Yn99xCABwZql3vqsKaVRxLLTtSFqtah+32PbVb2MjyYsXlWCW7XqxCiwJ1Q75QrfU+nit//yQGUO7yUoglcWdvPfSlFiUqSRlRQjRNW6O3qdU95DtxN+rUmVB9RwzUfKUiJdBorU6HscpNcNQjDWfv93fzHv46Fzf69Spx3LeIJX2m+smWSEUhmEYCjgIVBL8Hbb+y0URoJldsoJKPHHUq0ZQ2rgoluvFlpamkugnGaf2yt4qNR/QtFy85Yod2DwqlUDlSOVZCQxdw1W7N8cuMCoKqR4ryaDaTk7eGku0QaDwOaoaWil2x1u2b2gct8jw/VbUP2Mw+ADQK4Hmmnag5JPUq2opr7NL/WXt41AxuPYyyspTmfo2mjaqhh6YckuoDFntlPLgKubiPWPolMWjTpdKUlZkIDcu3SYIkqmqvTwBI+Yam5wONnQcN0cQKPAEWptjTpaaSdfVDd7jxhmAplJkmMFx4Z1X7ULTcnnjkGGYNQNXByPm1idO4u6Dp/HWK3fiVRdtIWs3TiYrvSxExiIhjUbTwnTK4qVmGvCEv3iJUwHkwa8OFp9GAvgT85RN3EziFBZAb2JL5VcyaFrI6WA90mTcBkEVu5Wg7bjYEgqIjlYN0jz+Gx87AQDRe6gMQSDLTTYmJgryjcWUz1UxVI5jtmnhBSFjbkA9HazR7C9rH8dI4Am0/PPkeUhfGBGUTj692MEX7nwK2zeNRMYSqiCT43qx5eEBucNfrF03lyeQ/28ZgtHDIkhHjUktpFJ7uZ6IvQ6cDjZ87j18Bnu3Rk2/w1B7At3wg+O4Y/8puELgZ195Aa4+P+o3tRw8L9vgXXXTcDRhniLnj1RBoL/73lEAvc0kOT7MNS1sn6gl/n8MwzArBQeBiPn4jfux/+QCDp5aIA0CLXYcjFWjaQyuJ2C7AtXK8qMorifQtFxsqiWng8nFS9tWCwKNpOw+5iltmkYrocw9VcWT8OeEJ9AVQ4ftCqUg3HqhbbuJi2BD10qx+9WyXNSneveQpmmYqJlYaEfNrotwZ7eC2oWhibq8h9Y67YzSvRTPmOyHwimF1EogP/21/z6tmwbmWsV9n+T9sSkmiCVRWQS7QiCte+ypOJbddMBvf+MRAMDMYiemffUgE+ArFZJStnS9ePtOrupg7Am02DXtH425TynUXkKIxApVFU4HGypSrXr49FLq31H5e0k+8s+PotH0+85jsy38/YdepdSe43moVpL7UYqxRiq5/8u7rux7Xc4fVQuhSO45dBoAsHuqDgCY6CqQ5tsOtk+QfATDMIwSnA5GjFQNzBKZyQL+Dup8245U8aop7lwE1WBSTEeDnSOFyZtfMSS+OhhAY0YJRNPBgoktVRn6gcoVvbK3G3hl0aVte4lVPcriCRRnajpSofN9Otuy8Z5rdmNHaBewamiwXG/NVy1KqvoD0JWIl+fg995+Wa9tXYOh06TMeZ5AoxkfBGorTPz9dK340ueSwBOlwL2UlQ4WBDiW3XIPWdUv7lNo08GSlUBFx4E8SiD2BOqlp8QpfymUUvL+iLsOVU4HGyp5z2qFOAgUbmUxpjLocnFFej+qKxjIS+Qt/o4Xn9P3uhz7qXx7Oo6HD7x6T6BwDZ4BVo8zDLNGYCUQId8/0sDMgr+T+sTxeTQtB6NV9VN8tmVDCESCQDLo0bZdbK4nq3mSkLtySRNzIFTaVWHkTVpAUil1OgnpYAaxD0TLdlGr9qfyAN3dqxLFU+87fAZzTRsjpo7rLt6aev3zkhYkKI0nUMx3MIk8e4QQmG1akWdYnnvXS1ZJrAWePL6QmO5HVSI+qQJZlciAfb5twxPRtK161UDbUasOlhaAAABTIa1NiHSVC8UCXqqw4voCqgCK63mJ50llcdfzBMoOlJWhHxoWsylpixRqrzRFFqeDDZe8gQVqJZAd6pcfPz7vV4JNMXbOwsvoSzVN/RlOGmeoPYEG1bNyLm07G7cPYhhmbVGelesaZ7Hj4D98/t8BAOds9nf6/+b+IyRtJ3lO1CpqOxdpZZ8lZqB2UVACWf3BE4lBtMOc6QlEMOFxXA+W40UqOwHlGtQPzyziP33xPnzorx/EB7/6Pdzy+EmSdlu2G5vyB/iGrWXYAW5Z0SBQlUgJ1Lb9+2fzQCW+4B5aw+dHCIH9JxcSKxFSlYiX7Q8GIqoVmpQ5mbYwPWAMXTN1pRQAzxPBIjqJatBXFEgH87LSwdQX8DsmRgD45qWDkFWOckVidTCVxZ0XKIGGX0GtzJzt3v+TMdVAKdReaYosTgcbLnnnOEEZdIIHQQgRCZj88Q2PK7XpZvSlereYiAryHhyc99ZC1geqOK4H2xV98wmukMcwzFqDg0BEnO4qgD70uotw14ffAAA4cbZN0rZMLRss5S4nVkUH9GAwTFEgyElD0UCK5wl0nPhUIY0oSNNLB+u/nTVNg0ZgJAiEF5C9QFy1hIP6iXn/nvw/33FF3++qDFbWCmPodDuPw0JOaAdTCk0iFYq8Rwd9vcowMVzoyvx//CXRAAFAI9EHeoHmwUqCpqEnBqCWQ1IVr4quKy2K8niaVVWMoYXITJHw/27ZTQdsG/eDQB/7yRdF3pP9tLonkDfk6mDZ6WBrPe1ymDSt+D4IoFF7pV0HTgcbLvK8fvQnXpj6d5RKIMv14AngV1+3Fy89fxKArzJWwe9Lk9/XNfVjl+O5ORA0pjw37ZhKfL1nYO2O9QzDbCw4HYwIKbV+xd5pmIaOcyfrZFWF0hYvQPFBy86hBKoo+t7INIu4VJJeCXe1QVdObuOMq3VNI0lVmWtGr4FZwhzvRjeg+Kq9vmn56Rgj2CL4AZT4+8hfZK/tcyQntIP3abWikwRoktRq8tmjnBg6rgfHE7BcD1VDT0zjyos0Hd09NRr7vkYwMQf8yXlF1yIBDypfJvk9BlPyKoopf06OIFCvRPzyFUeeyNod7/1dUSxXoGroCelgNKlUaWlzKr5SgQIlZTODyteozLQT+iCARinluslKIE4HGy7yGRhLMO+X9Dwe1R4EIURgfbB9Uw1bxvwgsmoRBVeIVEWfQZBabnWD0YPjjNw0pEgZ7RUr6S8kAgxH9Wu7HpqWi/GRilKRFYZhNhYcBCLinx56DgCwtTsYTo2ZmGvSmEPLAMTg4sVQHNDzeAKpBjqaVvLEU07MVReQ8tyPx1Q9MYhUCv/2yPMAgC3jvWtQxnQwGZjcOl7FppEK/ureZ/E7b70s4/9Kx3L8oEOaMfRaX3y1rejOHUCoBJKTwoFJupzwUk4M3/2Fe/HI0TkA/ve5+3ffgK1dpUcRpApuUIkooUoHS/KToPJlasQEcv321dIVPZEnCNQNphfoK7JKxFMs4B3XS67cFQSZircP+AuVYaSD5VECcYn4XiC6FhOs71WYI1ACxVzjCkFaOZOM3OjK6od0XesG7dWuw6duPoA/u+0QAL8q4t5tY8ATSk0C6KbWpj7H6nMJy/EialOJoWkkGxqyMthITDrYMJ6Bt/4/d+HwzBLefPl2fOnnX0bePsMw6xNOByNCBjuu3OXXfpwarQYKHlVmExYvqpUeAk+gNGNoxUDTXJoPAZFxs6b5i904w0tNo6kONt/d4Xr5nungtTKk8gwy170nJ0eruGj7OMmu0VzLbzPJnLyia2teCZRUYW6ESAmUtAs/jImhDAAB/vc6MttUak8arycpiqjUdm0nWp0NIPRl6rYx+Bmq96fridQgDdBTfBW5l9xu9bEkKFKdnIzKXX77hZsH4HttpN1DRbtpuaBNN5RlY+i27ULT4sd7CrVXmieQQbThw8TTO/fZU/oKQbXOJ08sYOdEDR/98Svx9hftxG//yKUAgCt3bVZq1/EE0uoj6ATp/e2YKqBB+zrNWHZqwU+zf90LtgWvDUsNZzkeDs8sAfCvC8MwTF44CEREo2nhyl0TQWBjarQa7Dwrt71koW4akQVqoAQquIBJMsgLozpwxaVRSaiqzswuWbjukq2x71HIh+VnXLBltG8nu4wlP2ebFjaNVFCt+JXBzrZs5SCZDPTFBeGA7sRqjXtBJKZrGTrJpC0rHYxqYhiXVtZQDEY7KYs7oLuAJzj8lhXvHeYbQ6t/QJIRfsXwjaeLLi7yKIGqCv2oyGifYgFvpfj1UKlo/Op7CYEmvfjiTm5Q5PEEyl1Lex0ije+1mIgiRSXNtOpg1FWpmH7yPAMSQ1dXu8w1LezdNob3v2oPNtVMVCs6rrlgSrm8uu8JlDwfVfEOk7TSgkCaerAb8H08TUPD9k09Ba45pHQwOceumbryWM8wzMaCg0AEPD/Xwm1PnuoLEEyPVTG7SOUJZMemYqhOrPY9MwsgQwmkaD59c7f6VFwQyCDanW00LUzHtA90VQoEC9RG04oqsUqUDrbUcbDn927AV+95JqhQNTVWhSf80tkq3PbkKb+9hGtAsfM4bOJy+IEhpIMNtE+dDvZ//NNjkdduePS4UpsycJGUyqMT+Sj4O7Rx6WA0aqwk5aOp2I867jI8gQpXB8sRBFI4RY7rJaoIKKqPAV3fsCGoyfKoINgTKP38UwT60pRAPdXvBr4AQyTt3A+iaoTftl1875lGZLyvm4ZyeXU/oJ78PkURgo7tRTZUJVTpYI0lC5Oj1b6A6zBUvw88PYv3f/kBAMDereNYslx0HJoS9wzDrH84CETAZ249CKA/DWNTrYJFyyHxymhaDsZrUb+bIFWr4KA13/JTnK48N1nC21ukFhu4pBrqBTvHI+9ReAIJIdBYspNVKEQL1EbTingylSkd7MbHTgQ//+pr9wIAxkf8idCSQnlswA+CAsBV503Gvk+lxhomMhA2UesPtpoVmvL2QfsDKXPUE8PvPO5f5+sv2Yov//y1APwAoAry+w+jslOYdkx1NsCv4kJxDewE5WMlUPQVDEJkGDcDaopKTyDDJ0P+XfFzZLsCZiX5+srjUKFlxV9f+RlF219OdbC13g8Nk3QFhHqgL+069NLBCjfPpBCosNJyqbqoKoGePeOnF++arPW9XjONYLOjKFmVFinS+1OD0QQqKQBYshxsGhmsBEqfDnb3wRkcOLWAd121C2974U4AIPMiZRhm/cNBIAJGY0qu1kwDQtAECGzXi/VrUFUC2Z6HkYqe6OUC9BZ+RRdhLdvDhVvH4it3BdXBCjUNwPdislwv0bRWJwpANJbsyM5XWUt+vv9VewCEJiWKSpfZJQsXbh2LNeYGyqEECtIWBytHER17z1x5IJBImA7meQJnWzZ+440X469+8RV40+U78JLzJtGy1dp2As+VBDNNIuPvpMk5VcUWy/Fg6FpkkaEaiPNyVQeTAeMCxtBCIK15in7Udr1IyeSgfaIASnYahqoSiD2B0kgKsgI0gb40RZZ8icJvhYmyPCWQmgea9Lp8w6Xb+16vVw2idLB01aNyP2QlB4GoNqzi5uzDSAebXfIV6p9530txyfbx4DWGYZg8cBCIALmzHB685CAjqw6p0EmomqOaquW6ySV7e5+h5nvTstIn/oCaEkgOeElKIINIpTC7ZGF6rD/QNMySn5Q4rofP3X4o8rqKWW2YuWZ8uqKkDJ5Adx7wq3nEVeCjkocDUYN0kzAd7OkzS/BEf6CpZupoK+7O2hlKICrz9aQgga5pJD4NSb43qub3aaXPJZqmFfaX8kS68TRFkMZxk42hKaqPtW0XC20nwxhasTpYjhLxGzkGkbb4pbqHgHQlEEU/wUTJo4aTqI5pSRsmtYqunA7mZvR1FBsOLdvFSII3GVU6WFylS2rVb8dx8bX7jwRzCnk92BeIYZi8cBCIABkc+K8/8cLgNTnZVR0UAX9AiVcC+a8VLffpeCLR50MiFzdFF6mpZqAEu7My3SzJE0gj8ASyXQ8t242kCgVlb9e4MfQTxxdw+LRfPeLDb7s0eL2q4FMSxg+QxZ9/oBxKoOe6KW2RIJBGU9lsdsnCplol8hwHgVyCieF9h88AAPZsHQ1eo/BpCJRASWV1iXZPF9sOxmJUlbpOpwSK8z+TJa2LPseeSC9rLDENbbieQIpKoKQS8f5nqKUKPfhsAwAS1YIq5uJ5qoNxOphfnS3ZE0j9HpL9TNwCm2KsZ5JZdnUwhU0HWa12cKwcMXUSJVBW6iuFQX1adTAaJZCIBoGIi0A8fMS3nzhns5+WJ+enspItwzBMFvEzMmZZyDHjnVftCl6rV/0OnyIIZLsexmImz70S8cXadTwvcwfbDFKeiqaDpUjQCcwiM5VAClVnJEnlw6kMU4dN0/InBV/7pVfgNRf3qqiZREogWRkvCUPX13waQNt28cq905EgjWEQKYFiPKUAWsNa6QXw6ot617heVQ8CyQBwWnUwiuvbaFqxzzFV+5Ybr6g0FZVAeUrEA/7zVtQTKK15Ek+gjA0B1TSMZleN9tpLtsW+r2nFU4XyeQKxMXTLdiOeZJIgSEagEInbkNGDucoGvgBDZFlKIMUxLUnVWtF15evrZqgqKVShluPbIMRBqQQaVJ1Sqn6B3tz3Iz92BQA6ZTfDMBsHVgIR0Onu7oYHFrnjpmqUB3QXL6meQMU6fdcTqbu/QDjlrHg6WLYEvVDTAICDJxcBRHelep+hPqjLdJrBIFBP4q7UfMDZpo2bHz+JwzOLuPnxkzhwcoGkXRkEGNz9GiFQAh1rNHH8bDtTCbTWJ//tBD8aqmOXufuDyMeaYvfxkaNzqJtG33WmMOuUwZGkvoKiRLznCTSadiTlMmif4PZ56tRi7E55RTHQneVjISmaDpa3RLxKMNp2PFQz0qkoVCJyc2QQQ9eKewLJNKSUSBlVmfsyM2xVrlyUxo0FBsGGD5NMHjWcRLU62OySjbGqEfF5pBgrs5RAFIU+kuwVeu0rNe9/huuhOnB+qNPB7u0qf+XzViXyeGQYZuPASiACOo4LQ9f6dlJXIh1MtTqY7YpM+bDq7kXTSvaB6FUMKT7q3n3I93LZtmkk9n0KFUGwgBn4HtQLiz+95QD+x78/E/y+dbyKfR95i3K77a4x8ODxU8iTf+vvHgEA7J6qJ/6NrLghhOgrmbqWaFku6lPR+9QgSmU727JjF0fyfFAoXb73zGzkXqyZhnLJ2CxjaNVUIQBYtBy4nsBkPU4JRKO2DWR2/gAAIABJREFUe+y5s7FpVapV/vIGgUxDh+Us/3u4nsBIQuUugEbl4qtCk8cC1TQMGUhP9wQq1vZylEBrXbU5TLKqIgFq95BMzR5UiABcHWzYpPkxDaLqCXS2ZccWEzEMtbFSCAHHE4kG9QCNMXTH8WILlQDddDCC8d6OST02dA2aRpP6LYTAX977LICeByArgRiGWS6sBCKgY0flpYExNEk6WDS/GFCvDpZn8aLqWTKXsPgFaCq2VHQN507Wk70mdHUz0KQgEHWKwYmz7b7fTy9aJLtG7YR0NgpPoMWOgwu2jOKnX3FB4t9USpAKkGRKTKUEalouRmPSIg3CxakA8CNX7ux7rWroyp5PWcbQFIHWTjdQWYs5R1Ql6DVNw1uu2BF5XbWvdkV6CXdJtaIXmqBnlYin8LvxS8SnL75ULkFSHypRCTLJcSwtwMzpYN1Ad2J1MP9flX6o0bRhGlrsWKwTKh6ZKIEnUI4S8arVwTrOcMbKhU53IyClyASFx6PluMnpYDpl6nH/tdA0DaauF6oQOchCx0/x/+XrLwzWBsFmBiuBGIbJCQeBCOjE5BjLyRZFOthC205QAqmlMWSZgQJh8+Plf4bjejjbipZWl8gAlGpp4yQVEECT4y2v4eAClXpiO7PYibwmd1dVaAa78P33ULBzpDBpcDwPl++cSA0mBsHKNbwASKpcZChK5yVJVfKCxSnBvK1je9g50f8smIq7s0AvAJzkGaMTVGyRaqW4yblGkG4G+Pf5jq6JZpiaYhDIy1EdDPCvRRGpflaJeApTX79EfEYahsIHJPmq9dpXUwJlbWawMXRyoBsgKtLQTXmNC8ZRqH6ZZOT8LE8/pKoEiqt85berNlZKr6Gk+SJAowq13OF7AtkJFg6moZFs7MlzddnOnhdjldh4mmGY9Q8HgQjoOG5EXlonSge75fGTOL1oxe7Cy5K4KkqgTGPoINC0/IFlvu1ACCSWD6coEe+XNk5ZvBBUewg8dQausUEwcZYsdZyggk6Ymx47odz2Pzx0DAAwOlB5SQYWVeTDjpvDV2qNK4Gu+5PbcLZlx07aqJRASZ5Dcr2kGiATQsSme5gFfWjCOBkLDNUAARDvq9bXvuL5cVwPlhtfHSkI2Bfsqx3Py2UMXS1sDJ2vRLzK4ijrOVb2BLLi+9Be+8XvITdHgQONMNhaVpL6IIBGKdVoxvueAeqqZSYdNyNlN4xqtU7bTbcnKPocp3lKSVQrUQoh0j2BiKqDJQXKzIpOkg7W6BaBmAp56Mlr0mElEMMwOWFPIAI6jhcpi0rlCXRktgkA+NlXRtNtVD2B/B3UjBLxQTrY8j8jKQ1JQlEdLMvLgiKVJOl7UOzAS453U8Hee+1uXLpzAi/bM4V3ffYenF5UVwIZmi/RH8zjHyFQAtle/ISw7/MV79Nhc6zhl4e/5oKpyHty11TVzyjJj6OnhqMJogyq1SqGDttVO34nSAcbXol4mQ4WFwSiaL/txPtihV8rqtr0vJ4qMA3TKJYO5nrImepEv7CTqHoC2a4fqElKa1O5xqwEysZ2PdiuSE3HA9TOj+V4EbVpr332ZBom9gp6AiVVWQyP89UcxzGIVD0nVXoFuqpQJe8zASHixxmATgmU5JtUIUoHa3bTwcZCG3uBMTQrgRiGyQkHgQiIKzkpAwYdxSCQXDTs3TYWeU+1OpjjRstYDiIXBnaBz5DBheRKDBSLF4GamZKKRJBK0rLiF5AUZXUlcgL0zqt24fpuGeXJUZMkHWy2aeH6S7ZGXg+urcKkxHGz1WTBfUpUGnVYXH5OtMx9WMWUx28hjkClk+B347dfqOkAGcAYvEerRm9invWsJ+F4HjQteYFBUb2rlw6W5Amk1n5SSiegHrB3hUBVj19chzEL+jP51cGS36dQcWQFc3WF6l2Af/+lPT8qi7s8itaeMXSxzyg7mRsyBOcnKxhH5bfCRJGBi6wNGaBbHUxhLLZiTI/9dtXUXrNLXXVLiieQqiq0kzUn1dU9h9q2i6blxgazqkTpYHHptbquwTQ09gRiGCY3nA5GQFy1AbkYayp6AkkPibRBV00JlC+Vp8ikQQawEhUERFVtsnawh1UdjCKIJYnLh58erQYSaRXmmlb8hCRQAhW/R21XJHrFSILJ4RpfAEzUozFxw1B7xgC/fxAivjISVYn4x54/CyD6GSbB7qDtplds0YacDqaqQgH8ymAAUItpX06ki3oCORlljSVFS8S7noitaiahUHFkBXNVA3G+51CaYrO4SiSPonWjGxM/eWIBADCSmA7m/6vyHDsZ1UYNAlNfJp48FfIkhqIxtJVgIt9TAhVrW86BJlM9gdQM6q1gnEmoWKurq9UCRVPM9zALpgQPkjQnLbrRwDDMxoSDQAR0YqoNUCy+AD+QkrQLr5pn72Qs7sKfUSSP2UoJYAF0nkBpixdDcQcbCHkCVaMlPwGadDA5cQjnw2+qVbDYlf0WxfMEGk0b0zETEoqSon4QLksJ5H/OWvWDkPfntvGowTiFn9FC27+GE7VokImiQh4APHVqEQBw5a5+NZMM0NkFSpNLnAwDeYMg5TKYnMekk6hO/AHgaMNPq41Te6lWyfM8gTwiK98TaPlfxK8slyzapVBx2K6XUR2MIMiU4TlU2NsuhxqR6jkrK0/PLAEALt42Hvt+oEhUOD9Z1UZ1feOe/2ETmPfnCAJVDAJj6CEogeQ8K6nSK6DeD+VRp6tuVs2mGFyrpuJJAmXroPKXKMjEMMzGgNPBCOjYUU+gXoBGrW2rW2UgzhMiqA42xBLxmuZLTItUB5PBhTTpLTBcLwuVxYWkk7DrQrEDL+lJoXsThxHTKKxOkCy0/bKrcUogGbxRTwfLCiR2/3aNBoF2T9dx+TkT8VVtFJ8xoBfgi9vhpFKTzTZtaBpwxUCQoxpU91MJ9GWoRAjSPDopO7S6ph5AlJPmuLRa1ecgTz8qP6fIBH12ycL0WHqKBKCm4vDVXsNJ1wK63m0Z/fRwPYHoAvZlRC6wL925KfZ9nWBDw/E8jJjJU0oqvxUmynJKxKtXB4svsW4YamOl/P+yKiGqHLtMO07emFS/RxvduVycwTXFhgbQU63GKX9VNvUYhtlYcBBIESEE9j3bwBsv2973eqByIdghTxqwlJVAGZO28OcMRwmkXrEly2uConx10q5L7/hpPIFqpt6X4103Dcy1bKV2ZwOFUXQRKa+LSjUJO4evVKAEIvAEEkLgi3cdxqmFDiqGhl94zYXYMREt+70cLMfDSMI9SqEESqt6YhA8A4Avpd9cNyMLbZp0sOxA6zBLxA+zwh/QU0sVTWPIHwRavlT/xNk2Wna8v4SExBMo8xqrpUlkBZl8z6FibbteulINoKmgVmaS0kfCqF7jXMFiDgINBRnAXpnqYPH+cqpjpazyl26CrzZWpilOAZoiBGlzLopKl0C8JxDgz+ksBdUvU4wbHzuOr91/BO+6ahfec+15q304DJMbDgIpMrPYiX1d07TujotiOlhKOUsVvx4ge9ImMY1iaQx2hhKIwg/FcTMk6ASDbst2YRpaZJFEmQ42u2RFUrbqpoET3aphRVlo+0GkTSPRCYmmaYV9SiRZQTiA1hPoubkWPvbtJ1Gt+AvqbeMj+KXr9yq1mfaMyR1yFQ+FxW462KbYdDD/X9VzM9+2MVGLqUZCkg6WlcpD4AlkpymB1HdPW7aLakWP9e6R92dhJZDIFwSqFtilfeCZWQDA9k3JgU4yT6AhKXX89r3AXyu+/eLHz0qgbORGRlJVJIDiGqd7M1EssJl4ghLxK6AEaloO6jHpqapVQPM8x0U3JCWdjI1JCrVaMOeKGY8plEYA0O6Ol4Med9UKK4FWgw/99UMAgLsPnsZPXbNbqZIsw6wkuTyBNE17m6Zp+zVNO6Rp2u/FvL9Z07R/0zTtEU3Tfqhp2gfpD3VtInf533317sh7FEaIaTu0uq75xseFq4NlG2oC/oBZZBEsd12Sjl92lCoLYMdLNxyl8Ctp2W6sqS9lOliceXO9ahSuWCTJ2vlSqSYhhOhW5snnK6UaEAV6UuvPvu+lqOgaiXF2UslbIKwgKN6+Hfg1JJtpKvtWWS5GYyr/mATpYLbnpRu+UpSIT/UEUn/G2pabqIKQ/VPRYLqXYdwsKeLXIINrV58/mfg3muaPA0XvISFEtzrY8IyhHS/df06l/TzVwSj76jLStl3UzPggqET1GmddB9UgE5NMUCI+Rz9U0fXCgRohfI/BuApewWZP0WB6Dm8v1XuoN87EjwV+P1q4eQBh8+l4fzuKQHTLdlE19Ejg3lcCqc0ZGTVUfTwZZiXJjABommYA+ByAtwO4AsD7NE27YuDPfg3A40KIqwC8HsAnNU1L1q+vIwITuDjpJ4ER4r5nGjAryQOjirTX6cpvs6gYWiElQZYJn5ywKEnQh2g4Kmnb8QtIneD4Jb7vR/8jUzMJgkAZFdqkoqYInSDIl717B9B4Aj19xjc4nR6rYnLUxLcePa7sm5SWcknh2SP9tOLOE5VCISlQWSVIB3MS5P8SVb8YICMdjCiQmxQEkl1gUbXXMBWV8nvnUbqoBFGESC8vrVqh7eDJxdTnX1PwfcpVHWyDG0On3f8S1WvsZKTl6YTVwTxP4J5Dp/Hvh05DCIEnjs/j+bkWTeMlxK8giFxVClWUQPNdj8HY1GZF1WweJZDqWJPlCUQRBLJT5lw6QfUxwN/0qcVsmBQtPsDQceDkwmofAsPkJo8S6OUADgkhDgshLAB/C+DHB/5GANik+dKOcQCzADZEOHS+69kyWY8OihVdL7y7DABHzjRx+PRSIP2MQ2VAz5PKA3QXLwUG9nbKwg4IVSRRmBhmelnoBAtsK36B3Tt+Ck8gO2IcXDcNtC0aJVBSIM5USAf7XjdVJevr9yrMqZ+n2544CQDYNVnHjokanjnTxD88dEypzbR0MIMgSBNUbombFMp0sCEFKknSwTJNff1/VVLC0oyhNYLFY8v2Iv4J4fZ90+bixtB5Fl9FPIHkfZGlNFJNpwLSU0lUUvJs18P+kws4MttM/BtDK17FMY8SiKKCWplppijhJKppl1nBUEOn8c8DgH3PNvAzX7ofP/2l+/HQkQbe/um78Z4v3EvSdhnx53L5iv1WFErEn236893N9eimp6pHpZvjO6j6VmUpo3VNg4C6jycQP+eiqD4GdMf7BOUvl4hfXT5184HVPgSGyU2eUeNcAEdDvx/rvhbmswAuB/A8gEcB/KYQYkP0RDJAE9chq6YxzHdzi3/3bZcl/o2KtDfP5BlA1zdm+Z8x14xWvAojN2/Vdh9zSNBVKwslLLApAgQS3xOof2JVr+pk6WBp5uJFz/9SV/Y6aIo+iLw+VLvwm0Yq2DVZx1//4isAACcVfJM8T8DxRGIQSCMIcDiBaWeMEogoHaydEOQgSQfLkOkbBCqLtImzQbB7mhTIlfgB+4Il4oXIlYZhVrRl+zXIc5oVZFLZIQ+qOGYE+opeX1kdLw0VJVM+TyD/342qBJprWrHVCcOoentlpZdTpoMdP9tT/cjg4nMbWAnkuPlU3UB347BgwFvOR8ZiyrirzofyenupzLfyFCtRnc/Jz4i7HhSqWSBF+cueQKvGz77yfOzdOhZ4QDJMGcgTBIrrlQe7sbcCeBjALgAvAfBZTdMmBv8nTdN+RdO0fZqm7ZuZmVn2wa5FAnlp7OJFsRRntzPfOp48eVNSAmWYgUr8dLDlDyyNJQu6BkzE7BoBNNW1snbAKPxKWraHWswCWyMIYgH+BO5sy454AtUqBhxPKFZ28o8t2fOmuMpCqjfSFtcAbTpYy3Zx7lQdADA1VsXUqJlozp4HK8O8nEJBIAMwsfJwIjVZUqAySAdT2B10MtV26t5eHcc3X49bBFAsHn2lVPJ3qBjF02rdnIrKka7qbjkBLflsZgWZVHbI04KUvfaLL16kj1caKqnTbo60Zo0wYL9SCCGw0LaV+n9JXLrxIKoqhTyeQFSnf2ah1+c/PbNE1Gp5yZuSCqj1dUGVxZi+VFPcDMjzHOsKaaNAeM6SvOmjOtZYrr+pFGcObCgqmSQLbSe20mURtSmjhuyfd2yq4cW7NwfV4RimDOQJAh0DEK55txu+4ifMBwH8o/A5BOBpABH5ihDii0KIa4UQ127btq3oMa8pOikmcIauK02qsnYtADVpb15PILOgMXSjaWNz3Uzc3aGorpW1A6ZpGlSzkFqWE7uApEoxONuKV0xJZYeKGshy/f832Vy8+KQkCDBlBBJVZeJhWrbXF3SaqJv4+gNHU/6PdLKqhciNbSXzcrnIjgkUUKnJkpQuQTqYwkOQlTZK8Rx07HRfJgrPpKR0MKB4HwdIP458/agQy3sO3EAJlP53KoGytHRFicriKI8SSGWHPKtCJFBOJdBvf+MHeNEffQfX/8ntyn2nn24cvxkj0XWCdLBU7zCa8+96An98wxPB75+57VDfexuRrJTdMCobh7LKXHx6vP/vMKv8aYobAr05dXJqMIUSKH0sI0iLf/JU7LM2ouDxyBRDzs/rVQNTY1XM5dj0YJi1Qp5R43sALtE07cKu2fN/AvCvA39zBMCbAEDTtB0ALgVwmPJA1yq90sbxaQxFZbdAtp+L/xlqSqA8pY1NQ4dV4Hsk+ZRIAj+UgoOi5wl4It3LgmLn5WzLjvV8Uj1+SdOKl1jLiZaKL1DWPaSy+5vn/gRoPYEGqzxdsn0cQHE1WVolD4DIGFoaRcas5KnUZGdbdqxPA006WHoFPooFdlqQhmLx2MrwRKnoWuH7M2+JeLN7jy1Hri/v62wl0LDTwYp79kjj9j9594tS2i9+jT2RrcSiNPFfKZ44Pg8AODHfxpzi7nInIX0kjGr6etamkqrnkEQuul5z8Rb8xc9dixfsGA/e26gLYDdHAEWiYiEgn+W0QhlFh5o89gSG4j2UVoUS6I5lykogN0N5ra4cB4A9W8Zi2y9ToHs9IH2yJuompkerWOg4G7YfYspHZhBICOEA+HUANwF4AsDfCyF+qGnahzRN+1D3zz4K4NWapj0K4FYAvyuEOD2sg15L9KraxHvGqAQI7IxUFUBt8eJ4IjXNQ2IWTAdLK70NqE/MA0PTjImn6qA7uxRN1ZJtAwQL1ISJlfw9zRg8CytDrWOoLB5TUiHDyPLiFJOTwWDBqy/aCqDnn7Vc8qeDqSlpgCwlkFoq1WLHwXRMhUKTJB0snxJI5TlL8jiQ7av6erUzFsFFKndJ8i7Aetci/+fkrQ6mEihLU6pJ/GtQqPlgQnzlrs2Jf2OoKJmWUx2sRHPzuaYV9Et51FRp2F56hT9AfQHpZnoCEY0B3U2Rt125E2+5Ygdef2nPk66zQctjO66AuRxPIMV0sFgPTMUNjVyeQIoVd62M6mAUqlPbEanKYtX2293+9CXnTUbbJwq0MvmRffP0aBWT3XWCatCeYVaKXPpRIcS3hBAvEEJcJIT4r93XviCE+EL35+eFED8ihHiREOKFQoi/HuZBryU6jgdNiy//bBhqixc5eU4L1BiKXhZ5Fy9FUiUsJ8NLRHHxKI8ptXKRrjaoCyEw17QwFSOlp0oHk5PaerX/e8iJVtMubjSXlVKoKZiBykXzSpWIv+EHx/Hoc2f78vmlz8XsUrFBN49SCqCqDhbvd6Pa/oPPNAAg1vjVJEgHszP6CekJVPQ73LH/FP7xoecSlTqG4jN84OQCDp9eSg0W+z4ZxdPB8hhDVwsogWTfGOcvEUa1ehcwvHSwLF8yv/3iY2UeBUFg8F6SFdLpxQ6eP9vG3q3+bv+H/vohtUC06wXB+CRUU2HypI1SZGu17f6UpE0hBW1ng+7AO56AkcOXDFCzEAjmKmlKoKKeQK7IeY+qewIlFoKAeh/xzR88nzheqigqJUFKXkIgrix93Hrh1idOAQCmxnwlEAD2BWJKQ74kYiYRy/EwkmgCVzxAA2SrFAA/xaSocaSds6JE0XQwO0MJpOoJlE8JpF662vEExmvRahhU5b1bdnyevQzcqEhLA6VagvxZxTg7z/0pPwPwjR9VuPVJvzz8u6/eHbw23l0ALHWK7QBneQRQXOMgWBaXDkbQ/pMnFgDE7wzKAF3RST+QwxhaLrALfocPfPV7AJINxlXTwX7zbx8GkF49SCkdLGcwvSpT85aTDpZTCaSisljsVvnbFFPxp9e+SrpZui+ZbL/oJXbcbE8mimDrSvLosbMAgJ+6ZjdMQ8OhU4uBd1wRstR8gHr57axgHJUnUHtAjfIL110YjAMdBdVsmXE8kZqyG4ZECZQaBCrUdO7qYCq3UFb6t0agpPEEMDaSompVVQLJ+WLMd1ANkjHL58ySb1J/xTmbMdVVYxfdlGSYlYaDQIp0HC82FQzwd8iHbQxtGsWDQHmr2hRNB+s46UEg1fLbearaGIrXwE7xy6BOBxtcBFeCRWPx9tuWC01L97wpOiHMMlWWyOuj6gnUtl1cvH0cb7p8R/Caqnl2lhJIteIJ4AdgdC2+zLec9KosvhpNvwrf5edECjIGC2+VQGLW4q4XzFW7vkn9mPrE3783xlOCHCr9qCdEZgl3+Rn+8SxHCeT/m88TqNhJknL2uJTXoH0FA/k83mEqQaw8SiC5Pi6LJ5BcRLzlih34+E+9GIBv7lwU20sP5AJqKX/yM7KKNFCc/8FAxNhIBR/7Sd9vauOmg3nL8AQqvjkZBCDiVCiKqdOu5+UKVCqlg7n+WJykelRu3/HQsl2888W7Yt/XNLpNw9iUPE4HW3FalodzJ+uoV41AmZ6nIibDrAU4CKRIx3ETF9iGopdFHhl9tWA1ACFELi8FoPgCyc5QEKguHvOkg5FVk4i5BqppMJJvPnIcQHR3TZ47R6FEsCwdnpROorIz5V9fLTNVhSpIEGfuKwNnhYNAbrqvUS9IU6h5AMA39h1LfE9191QIgT+77RAquh67CCBJB8t4juX1VzVIbydcQ9WJ+VPdEtJp96lK2eS85Zl712L5SqCsblollWe2O2GdjkknlKgEmbJ8yQC1DRPH8zJTYcqmBAoH5mTVSJXd5bwV1Aqbc3sCQiDTE4higfr1B44A6B8v5RxsQ6eD5fYE8qsUFpmbpqeD+f8WT+/PpwRSGWfufepMemqzYhBlLiOgbuh06WBJ14CVQCtLO+RTyelgTNngIJAiHdtLTbVRSQdrWr5MP83QtFrRl+UxIZEDdR4vC98TaPnfQ6bKJaErLh5zKYEUA3Hy3CaWWFeU0APAdw/NAAB2Tdb7Xg8UNEMy3AXUcshtJ9tnAqD5HkAvoBVG/t4qWEEts0S8opdIY8nCqYVO6v0DFJ84P3RkDkCyz0yFIh0sQzFoaGqBsou7Fd7edVX87qnqxF/yv7z+osT3KgXTanuL3+F6AmUrgYr3Q4tdU/VNMSmvEpUgUx5Fq0owOpcSqGSeQPMtG5rmp+j1dpeLLSzkhk+WcbCm8Jylmd9LKCoXtW0XX3/gKABgNKTsG+mOAxtVCeTmLPIB+FVrgWLjcdtxUdG12M/SFAOtWVUoAXW1WqNppW6IqKYsygIVEzGVOgGadDCZvjtajbMooPHdYvITnpfK6z6vkLrLMCtJ8qyPyUVaOpihqwUgGk0LFV3DRMrk3E/VWv5nyMPKM2+oGFohtZHlepjMYQytMvn3jy8rzaBY+0Cvkk9aNQlVee98y8EvX39hpMR3pYByYJCW5aWWxlapyuPlXPxKxZS6DNqLnCO5A5OkIsli2MbQZ7oLN5nSMYimadAUFvBZMVwK83Inw7BTdYG9d+sYKrqG3/qRSxPa93dnhRCZqrM4aqaOn3vVHrxsz3Ti35hGMU+gvL5YQK8PWY4qK78nUPHFUb4FvIoxdL50MJUqkdnV02jUiCtFWME5pbi7nGecBGTKX6GP6AUrM9LBVBeo4WB/WLkWKIE2qCeQvYx0MPksCBRRAiXPJ1RTm+PG90FUN90s18N/eOm5Ke1rBc5Kj5bl33+jiZUu1fsgqRLcMh5VG1H5bjH5CSvUfX/Y4vNRhllpWAmkSGo6mKIfzeySjcnRaurCp1ox0Cmygx2kGeQxNC2YDpZSKhNQN5QNqtpkVC5SCT4EpqZJQQLFykVPn15Cy3YTKjupe+n4pbHTU3mKnh9PCOSZd5J5Alku6gPfRQ6+xxrNQm1mG0X6/xY9R4E8PCPVpmg/sRIKCJn2l/wZakE+K8NAXiWQJYRA2/ZS1XCArwQqVAExxTNskCKeQLJvzK4Opl69a1jGzfk8gYatBFIPhq4UTcvBjT88ERyrqhIoT5APUNsQsL0cYzGBajac9itNWAFOB/OVQPmCQCrPQst2Y/2A/Hb9f4s+x3Hje/Qz1OZbLSt9LFANoqT59fjtq28ayn4gbk7BnkArz4GTC8EzoWka6qZRWJm+GgghcP/hMzg8s4hbHj+JW584WRrvPEYdVgIp0klJeVKpwgD4nf30WPrOSNUo5gn0/7P3rsGWrGd52NPda63Ze+acOTOjy5F0DhIChNAFCYeL7EpsMBiMCwKUA9hxJa44KbtcFVeclHP7EUIZ54crBv9wBRcmiZ1U8sNVVOLCBRTIxlyCDZibLFmAhC7oLh3pzJ6Zc/bea/U1P771dffes1d/z/N+q7fWmtXPn33O7N5f91rd/V3e77m0RaAx5WBVvbF4AsR7xVTE5DaLNKNk5EIx7f/JH/5FAN1Evw/PvoiR8pz39MpXwWnUbW2zhrhtOljkwHJWlI/tQt4+dl3Yr37kRfy1b36T3GaIyRG7u/lgbeY6tMOZbUFqswmxFH2AiH6O9E3Ky5orFjcNUmhMIP/+DrHhANeHnBc2ySvAMYHmhnSwquG8PmJYFj61b9grw95PLwsnIRmrfcbbbp/kYP/wVz6KT9zvkuxuLjIsZqmZCeSfN0pqY32GCGn2NqQq/SJQ3+jds7EPVQ7GeD55xLwLyysk2R6xbLtlubltj9gI9NXA9QPx6WCbQj4cVJoDAAAgAElEQVQ8si0Uafyc4s7Nx+cUkyfQ9eLRssCLp3kbPgG4uYbVo/KLgd/5xAP8uR//tQv/9sPf905879c+v+EvJjxJmJhAkVgVA3KwyKr//bN8kEEAAItZYmLpKJ5AM2M6WGhxl0QyCIp24jm8wxyXDub+dihdaxuD7lX3eb6FdLCrzJT7SCPSKuqm4Z6f9f2J3QF7cFo8Zrh4czHDc3eON76DIYT8SmLlYIwUJmb30Rex/s//9Buu/H0s2w5wn4GRg9nf40AEfYQBe2eiOTzUuUK3zfze/30INk8gro+OSe8qiAV8jMH+g/PiygXL5fa95E+FwgTaB7+Mzz5aXvh/Jwmb44Excab1zgswRWL6Ib9JlA2O99sJBwCAv/U9b7/AjvO+jIfKBCqJ9DePmHdhaD7RjgNWOVg+vGEFxEsK3abYOCmFQPd8bmJfxxaxAPcZ5tnVvkzbsCeYwOPzL7l4+O/5mk5ieLRnRaDPPVw+9m/v//TDL8KVTPhiYCoCRWJVbTaGjpUiOSZQoAhkZgK5n4zFxiKzmU+HZB6xyUslQ0GPlGv573azsW+CCMueFlcygbLtMIEGjaEjFndVHZapAF2yUYwxdF7WeGlVXlkse9XTN8y+SeGIePfTLpPwUpsBtlqEd5i//k3x59tIZlsVw3Kw2HOc5VWwSGZtP7Qz6zFLjZ5AhOmxR5sOpsjBmiaYDAbEvseORTD0Lsd4q52chjczsohCHxOPHfseXyeuihe+e3NhZwIRKZqAl5JYi0DhsXgbnkDea+MN925e+PdJDsYzgWL7081ysFhPoOG5ijtHTLG7Rlk3gU2xWCaQM20eYkvFMqKHvqdtvGMTeHhpXj/U5XiRjeJNlpf1KF5Dn7miCLQHw+SELWEqAkViVQQi4iPeppOz4kqvmD6sEfF+0clMHGLSwRYBs1EgIh2MNTSNGBV//vc/B2Czxntb9NurTP78hDqGCTRE3wbiFo9N03DG4p4JFFEt++UPugS1q2RVVlNfICwHa3dNrbG3rW/VOH4oRSB+O5YB8bEXT5FX9eCkIEZytiwqvP/TjwaPyRJ7kYktAs2tvmeeCcQYQxvTwSgmUMwzVNcUk8a6+LpPFIFiJCqaJ9Duz25Prij23Lu1sHsCec+nMc3FKTlY/Pf/c+//LADg1qWidycHO8wiUFGF3wGP9l0Qv6o/9w9+Fb/0wc/j33ziwZW/bwu5xlsQmqsAcczuszw8FsSy1X7yPZ8GsHlTZhuePUPfUxbBCJ2g45/8zqcAXJy/jyEHu3+a4+0/+HP4qh/4WfyrD31ha+1++PMv44d+6ncf+/efft9ntnaOCbuNqQgUib/8x78M3/u1X3Ll72ZZXET8sqhwM0CPzVJbgUbxBJpljtGkspoK0vDVTEEn5GBZuh251juff+bKf0/TOM8hAHj29g182StvPfbvnjkQawwd8gSKMWRlnp/OE8h2HqAzfv6mN7/qsd9ZTX2B8dPBGClGEiHJG5vJ9OkHbpfo7c9d/fwDcQv4l5Zu5/SNVzz/Xfv2e8D4hvnfW/rRkGdYHy0TSCgCsb5bMYuXilhAxhSZVuVmtqxHjJ9IWTfIAvd3n+Rgy6LCs7dv4Of+yz/R/tvdW3YmkH8HQs9R1DNERsTHDsV+If81X3Lnwr+3crA9kmFsEyFJbR/W/vrXP3p/8PcxY01R1SiqYZYO4AuVtofIx3YP+fMliHtG/fW/+vbRlb/PtiSJ3LwpuZ357gQO/pt+62tvt/82hjH0x++ftZtHH/jcS1tr90MvvAwA+Na3Pov/4Tve0o45rwgoUCY8OZiMoSPxHwyYZ8UMWMBw8phHZtQY+90UZoHRX7xkKe+9kpcBr49YlkVLcx+eeMZI8sqqwa1FtpFKH7M48p/7z3/966+UYvjPFW0MHdj5snsCkUXENiLe/jlOzgokCfD83ZuP/c5q6guEF/H+n2NTc4begyyikBjyHIplQPhn77m7xxuPiWHq+InNW1779MZjYhYXvggXYtPM0tRUbA15hvXh71FR8uepyUJrzALbGX+HijQxfjHhBWpMYhHHBHI/92GBlFc13v66Z/Dm13TvxL2bdiaQ/8ihdyBmLGs9gQLeYduIx/6KVz/1GIP50OVgUhFoCxLhK9uNGAeWJGMzpp+7v35/hiwWYtlqRdXgLb2CwOPtxxdphuZ02zBfn8AjL2u87pmjC/P3o0XWFhy3hT479ORse2379Nq/+V1vayVt3/XO1+G9n7ya7TfhycPEBBoRMRHxVd2gqJqg4a1bvOgTH39ZDIN4YdnBrhuUdUN5AsWyLELx1TFjblnVgwukNLHL2fwCeNMuuU9ziTWGDnkCWSc9rF+Jv88xrLiTsxzPHM+vlC9aTX2BsKdLbOIJJ5OITwfb9A5sjckU8PoAbMXEgkjXssoXgO6+hWSv88xmsP9bHztZ/z2fDibJwch0sLiI+GHPJ9d+RIGAYhq5n+oz1DQNlQ6GtggkNf9FwVWbJ3dvLfDgvDC9Y92Gz/BxMaa1vCeQ/QY0TYOfed9ncfcKk3Hffx8uE6ihi0DbSIy8ClGG074IFGC+x/Rznkk3ZLEQW0RxBe/AOxBZpzwvatzY6Am0H4XuJwXFFQnIR7N06949/Q2Av/fzf7C1FMT7a/+5vlx739LNJsRhKgKNCBcRb/tbv7gL0eitg5aaDtb/GwZ+oTPMBLp4LSoqcvcxKh2sbogi00gslCyOKQUAy6IeTQ7GpoO1crCIYtbpqsKtxdXERaupL+Ce03mWbGTExTAUgK5wOlxItBeL/WRgU6EvlgHBpF/FGLxL/YTRLwYIF4FuzGzm934n7asH5HIe/j1XPNyqmmPbbcMYerj9OEPW0ALVai7u+64nyROoqB7fPLm1yNA0tgh0Vvod42HIegLFLLC9FOzmFeNAkiTOG24fqnwjIBTC0Ye/Req78Mq178n//Z+9a7BdExMod31iOCLePl/xEp1bNwY2xSLTu0IFbytzv49H5wVuH43nOTSBx1UJyMeLcTyBAODtzzmW2cdfPNtKu6erElmaXFgjHC8yLEcwtp6wm5iKQCPCRcTbXiY/2QvJDJyXhSUdTPAEMjA5WpbLYOpP3MS8XWAPDrpxu49lMB7bvrPTFvo2SnncT7NxdlUjr+rRIuJpTyDPFImiWW+e5FpNfYGrB/E+YguV/p0ZLiTGJaoAw2kkQAQTiDRfB2zfEZOuFZM+xspejxY2HX9RNVhkKZ4JRKADRk+gmjNfj0mFcaayzGaD/R0Ix5PbnlM/9oWLWHHF3OvEVUygLllO/wB+EyHUV8c8Q4wnkPNbiRsDAOAbv/JxXzjgsJORimo4hKMPK2Pn3q0Fvv1tr8G/96ZXXt1uBLM7NI55xMlSw4VKIO4ZKoLM8Xg52MnZZqP9bQWVTOBw1bx0DE+gk7McWZrgv/v2r1r//3YkYVexgPct4n5CHKYi0IjIIiLiV22BgDHK09v3f8N4AnmmjcK2KALR6l3bdhYEs0CNpd+W1fACZhtysLApsa395foeHA2wyeLSwbjnJ02TqGIT4BZ7myZvMQbseTm2eTmZDmZ8Rs9zf4+HC33xhdZxvqPQOwDESfLaFMTAAvh4nmFV1jLrrqrD8eQerSeQKgejmED2e1zVNVWkiUmOCheZ3E/1M1TUwm7/PIEuvw9+ol6YNnzczzHZXpQnUBrHBAqb+O8H02sMFAH/xT6s78J5IGQihm3XFoEW4WK09RZXbcE4tOkTM08ZZgJto1B5/zTf6Gs0GUNfL/75773Qhlt4bLuIcnKa40d/4cN45nje3vf7Rn+4y1hdxWSaZ8jLOmq+PmF/MBWBRkSM1GZVhJk0wFoKE8UECh9rMSguWr+e8OQ/mqUwmA4WN/F3crDhBaq1fTqZyvgF+d2IsSLi66ahnh/AvQsxVP283HwfrKa+rl22CGRqvvceDLPVrIXE86LCYpYOLvBipUJAQOYRsQPMMIFiTYOB8ALYvyNLUW7DsFw8/HeYC88qmw4WFxHPefaM7TkEWJhA3P0dywdlDORl/di4b2GRebTpYIHHKIrtRbByY6TTQE8+PTBeHuoCuKiax7xJNsFaVH95WQ6m1cYwQs+J+HZ/DjszmpEsRnoCER6SMfL+oqrx0rLcyAQ6ZDbcdeMT950k6+P3L0qzjuZZu37bBv7b/+e9AC4W/06MSZGXcdWGgy/EbtvXaMJuYioCjYjMWKABenKwkCfQutAk76CShqlAP92JP4dvn4sejpt4hjx7YmRITg42vIC3Np8H2F7djp2tfSZx4zoi4v15YnYWrjLg87Ca+gJhLwVfX4xJ18rS5Mr0N48YivsykP4GxJv6ApwczBoNDISMoe3tt3KwEBNovbhRadyM6bFHkiRYiNJFPh0sjq3GyMHi0sc4po7aR1TEwq7f/j4wRZwc7OLniZKDke9ADCORKRbHLlDbvmKEpM59RtM0a287lgmkF9WrusHD82IwOjpmw8QX30NjWYxvFbMhEGusXNYN5iPaE/jF/71bV8uPD5kNd924zADyWKz9Bbd1H158eQUAeNcb77XFv20xgYoNTCAAkyTsQDAVgUZEzKQqZBrsYSnQAN1AMbQ49fCDppJS5SfnoV1s9x3FUtBDu4/2gfFDL7w8WESKWXz5Qt/mePI4KVJHsR6OiLd+/2xEPODYOrFysE2Tq2g5GMFCiZEshhaoWWp/Bz70wstBtmDMPf7coyWAgDF0BGMtxIYDevfA0L7vf0PF7iPjxIeJV+9jniWaMXTDFepj/VyCRZoIRmXBFJlac3HtHO0YQEbQ7wNT5CqfiVmUHIwrAm3Fb2Uk7zMgLB091GQk/93znkDup/JdPTovUDcupW4TEkO7Hss8PFdx57DP55iNyfg02ZB9QFyh8sHaC2bTfTjUQugXA7/4wReu/Hf/Hsak+vaxKjvJ/9E8w/E8u5AWFoP8is1Vnzy3bV+jCbuJqQg0IrLU7oPSMYECOyOpbZHqN6OpdLD1BH4MJlAME6UkJGcxu1N5WeMPXngZH/n86WD71nscWgAnEYtrgJODxexMsRHx/jxRTKCAHMzKBFqVNRYDvluxbKxVEU5tiZm4/c7HT9rUnOH2bSf4kX/2QQBkRLxl8l8QRaCI9LGO8Th8nC8CqRToasCr6irMZxYmUPi4ON+ncCErRvbKRcTb+mk25TJW1nldqGsXeX+5r1tEyMF4T6AYvxX/noX852ztA2Hp6KEmIzEJjn1Y3oWH56748MzxZgP8zFjIBXhj6LGlwbGFxKIeloPFtu+LQJvuw2QMfT144dES//PPfuDK3/m5jCVt9Cq89pljAMCfesurATiD9vvbkoMNMIEmOdhhYCoCjYgsTc0MhVUgOao7h22XfGxPIG/CF2ICJUlMOlU4Gcb3b5aBkWEFpFuQgw0tgGOKZMzEKkYux0bEA3HSSODqHQuPeRYXEc+YElsX2A/PC9wJJEfFTAwXs3RjWo5HzDPkMTSxjYmIf3DuJjObPA6AODkYm4zkWWbq7l1o5/cyMrFozMS3A/G+T0yRxi4HG14YufbdT/UzsEW+GJbCdWIT2yVGDuaft1BXnaZ2xiOT1Bm7QG2LHQPG0Lt+f8dAToZweFjehT4bYRNiCq3nhHTdnQPrc+gn6TyBhguVsUygITlYDPPdtT98r2OYUhN4vNhj4vzeD337hd91ffV2ikDP33VFoP/oj74BAHD31nxrTKDiChnpJAc7LExFoBERY0pMF4GMUonWLFLwBFIW2izTyHnq2HewAWA+MKgnxu8H4CrhUXKwKnyPY4wQ24lVINEjxgeCkRMC8UygYTlYai4w5WWFGyOZEgNrM7+BAgcQ53PQAHjFU8Ptb0MmEYq4B2zn8JOZoUJZzOKCNYb2RQq1mOjkfvwwmorMu6phPYHs73ER8D1z7dvub9M0zrSWjogXNzPIIt++RMTnG3xvYuRgTcO9A1sxkB+8z3HF6JBE/lCNofNAcewyLBsbTKHJv4KjGkNHhBC0Y8FQmiwiPYECxtCxGzKhmPt96ef2HY/Ou4j2yxLGbTOBzvMKz96+0b63d28uthYRv7oiGMXqjzhhPzEVgUaEuuvbR5cOxsnB1LmhHySYBYY/h8JqKgmWjj+/3W9lfY5A8hJgGxSZTjBm4sn6oZiLTBQTyD7paRrOrwRwk5ax5GDzNEFRNaZiYjgdzP20fkcPznLcCRSBYgtxzAI4dlI4VOiIKbTePy1wa5EN9nMxLA7WGNq6yC6FiHhAHxOahmMCxfq5hI2bbYuXzjCY9OwR3wPe9Hh9/I7rwTaNCYuI3eVKKJTFJ3WO6AlEyKe3tO7aK/jNMN0TiD9HyI/JtWtnzS5JOVjMWEA9oxHMbsCnyY4nNwttasTOVyZwGErn8n214v03hLNL4R+uCLRFOdild9rqjzhhPzEVgUZElqbmSSebDtYVaLQOh6XRA93uj7J4YQ1Zr2PiCdjYNL4T/K/+1FduPCZm4smwvWLow4wcLMYTqCL9Svx5YiLii6reuFCdGZ5Pj6AcDHFeIsuixhGR8GeW5BFyoZhC3+vv3USWJkHJImArtC7LKmgG2hUI7HKw0Hfk2YQyE0hIB/PXofQXbAJfkth3fxk2k3XxwhgGA3bZLsv02hdPoE0JWLPWE8jwDpAbPjFFGtYTKGZt2vnSzDa0f5gymILYTOrDwhYJ+TH127XKwbI0CTIGYwzeGfuA2CLNsqgGNzRi2WploKgew5SawON05ebW/8df+vrHfrdtJtDD8+KCB9TRPN1aBP3D8wK3jy6ysP16ZFtFrAm7jakINCKyVGPP9CF7Aqk0ekM6mOQJRBpDp4l9d1YxhjZRlNdFlHd8yTMbj8lS+8Szm1iNE+F+nrv2h9PB7EWsmpSqAFswhq43p3hZmGoeoXQw//HMkkXSD8W8+Go4PxfrxPPpoxm+KeA5ZI33BsLfP9BPyZOb7xW7OSZQKb4MTLJWH4l4r6uGk+zG3OOSkoPZFvD+nRxrceefiVA3tDeeQBtkN/OtpIMNHxfzDFGeQBHyeKCTjm7yD4uN395X6MbQ7qfyXXVMoAHWdUSB5jyvcTzPgvPRLKLQ1CYJDpwjtlC5KurB+ZbbkLG3Hypk7Us/t+/wa4O3vvb2Y7/bNhPo5DS/kAYXY3/wWNtnOe7dulgEmkdsOEzYP0xFoBERs8O/Ind3zMbQZKoKYPUE4oyhYyZuflAfOkUURZlI1xpbDhZjnN16Ag3sTFmLWHXd4Nc/eh/v+9RD6vgx08HaBZKhmhWUg0WwXICwUSQQx4ar6oYwX49rn2dZ6Ce5Kg778fZhbp+VwnSLbO0chegJlIljQl03YGpM0cbQwSKNrR8q2+JAOH0M0BdINVnkS5JELsB9MVAEjaHtRSDmO4qRpQLDjK+YhDkAODkrkCRDyUiHGY+di0Ugi/9WQWxYJS2bj262xXlRBf2AgEhp8Jq5PDReJsa2AdfX5VU9zLyOfAf8FGfTezZ5Al0PlgN+m10RJb5Qc5aXeN+nHl7wlfT2B7FomgYnp8WFAhMQN5+esH+YikAjYpbapTx+0L0xMOgCMelg7ifD5LDIbdrBivEEMvY1ZVVjniWDu0fW7wfg5FQxC+zcS/4CUhvrwoWRFFo9mV5algAQjCf3iPYEGpKDGaU8wPieQCGjSGBdLDYn5IUT2mJlHoxfDGD7jvLy8XSKy7CaBvf/JsgEap8hlQmkRcSPlQ6WROwwO2PosGdPA0uRj2UCuZ/qc9reX9Y8e8cXR6uNTCD77myXDjaebLRlWQSSkWIWpydnOZ45nm/sT7dhgL+P6DyBRpSDtebTw/cXsDG7l0WF40X4+ttrN8wZGdmr6+dsWK7f3dB8MSa9K+S1OXkCXQ+WAxusiy3KqT70wssAgOfWCWHAmgm0lQJThbyqHwsu8WPNtuRsE3YbUxFoRGSJ3QeFMT325wBi0sHCx7ZMIIMxdNCHIEJORbEUIqQkbREoSO81MoFIs0WzcXYbiTo8cbNM2hKx58jSNNoTKMQEMsnBRvYEKqj4bXvyUt2QvltjGk9H7ABzTCD77iabUtgaQxs8gRRj6DHTwaxvF1Pos8pG/TgQlkTaZM1sgcOdY/cXR/kGGXjXx1nSwdxPpp+wMx7DjK/Y7z+UtLgNA/x9xLXIwShPIL1dj/O8CppCx56DY7Xan9E24SyQxgrY5xOd0f4wE2jX+7l9x5CH1TY9ge6vJbDf9OZXt/82SxOZsTzU9mV5rb/+iQl0GJiKQCOiLUBYaPSE6THQLV7UIpAvvEjpYEKnUAdoqx4xRY6iagbj4V376+sxTkyAgLFyVHoXmw5mar69X6HdWUv76k5cltplbYC715u+pzbe27BAWgU8aVqGgnGJXQ4wmDyszxBvimufFDKeQzFeEFdFlF5GjOdQTRa7WyaQnA62WaZ4FVQmEGP8DcSxvYoqvEOeGf1cmEI0EJEORgYQAHGszevChz9/CmAzE8iyu9xJIoePS1NbgALAMYGc1MbUPADHBLosXehjH4p8Y6Bo2WNcMdpSiGAkZ7HG0FQRKLWPNZSJf0QhkUk4sxrge4TeM6usdoKGX/nQixtVCDF9dR8/+Z5P4T/5R78BALh7s5PAzrJkK0wgnzB2uU+NSaKcsH+YikAjIjPubgJAJU6eZSYQKZMAbEwLlgmURaWDcQtswDbotpTPkCeQsa/MqxpJEk43Mxtnr1kow3K5uOhtFlmaxsvBNnxPFs8qj7ysB+V4sZOqklhgW58h9h2OWfyWFec5BNiNoUNFlJiJv24MLTKByCKNRyqmg7Hm61HG0ISkzVqoZFkK1mJ9J/cLH7sP6VEf+OwjAMAbXnHzwr/HyMFqcsMnxrPHj5WhpEtrMR0AHp2XuH10dTKYb/8QF7+dVIv1BHI/JU8gISLeOtfiPIHs4/GQpNzDKksFevJ7aj5hZ78DA+lgEdc/gcfJaY7lhoSubaVr/fV//J72v193pycHS1PUjX1d4OGZQI8ZQ8/sY82E/cNUBBoRmZGlA3QGpWEvC1uhiWUauWswRMST6WBJZJFjKJIW2E462HC6ln331CcjhTyNYnaNKCaWhWGxvqYf+u63UcfHeAI1TTPIuLAa8TVNE5aDRU6q3HUT74DJnNv9ZORaUabBhLk7YJNrFdVwEQ6I22FmEmGAXkS8eBLvS8ZCLbqy6WCxpr6cHCyC0Ur6SqnPkO97OTnY7qdHPTov8eztG/iSe5eLQHY5GFsEyiJYECdnBW4ussGFfMwzCrjx+OZicxHoUD2BGKlWH5awjJZROZisdfFYBWwRKIrZTbCNYsaavHR/xLClzLLLwLogVm42gUNe1vj+r3v+yt+Nka7Vfzdi7A/6aJlAj3kCufYnT6DDwFQEGhFWvx73N3WQxQF0CwR1B9szjZhdbL8IVBbZJdl+VJGDWIDFpDv5Sv9RaHczIgGOWQBb++KiqsNyudQ28WcXFh5ZmphjLVvjy41yMNugWNYNmibkcxA7aQsbQ1vfgYostMZIFquGKbSuj7V6MpEsEWuKHRAupMRExEtMIPFe8Olg9gVwQcgkMmM/URBeMUAn11ML6krK5T4wRe6f5VdGoM8jdpf9Zx5TNnqy4bovtx/DUDjPhwsFMWPxPqMzX9eKQMq7EPKisbbrwcrBomLoi2rQrweIKzJ1bKlwocwcBNH2p5uKQO7nIRZDrxPLcvPz2nkCcaEpV2Ho+YixP+jj5LQAANy7nA6WTp5Ah4SpCDQi2mQqo35ZKdConT6j4fewJGyxRQIrEwXgpBgxg+5pXmKRpYOLeLeAl5sG4E2JA5OSCOPssiKjn02mxP7vySJQxH0uAhMfqwa73UEdKR2saZq1b1X4HbB8Nb6QGypwxEbQh9YWcTIA3hja9B2RjEcrm4xJnOlD7e/YIlOMKa5jAoULcbaIeL9A5SSFuhzM/eQT1HZ7cfTwrLgyAr2bmFs2lPxYPHxcDFNq03U/3r6peQCeLRLwzzvAdQsj1erDwtgpiWK6RWbmcV5Ug4xrj5ixYEmYT8fItfyifKgYlxnn69051vP2Df1prNxsAoehgnRrrFza74GX1wLAu95478Lvuk35uHv8YM0Eun10sd9O08SZT09FoIPAZm7thGi0Hb6RRs9ItVomkHiOTq4VnjhYmBaKDCDGryS0+xUz6D44LXDn5vDENmZhEfKjASLTwRgWinHi3xX5uONnWYKVcVAsAzudC+MCnikCxXgQtAWIkSLiW7+bwD2IeUYrosgRw7Z7cFbgToBB4BcXMbLFUKHML0A26fw3gTH+7kNlfdGeQBGSvyG/ra59Wz/EpoP5HX614N2lg4WP3Yf0qFVZXfk+zI1MNYB/B2LkWkXdBD1pYp5RIMwW2Yci3xjoTJu5fsgypnXeW0NFoASJke11ntekJ9D6eozy/nARyP20PEZeDjY0XsZ6DLLpYAf4Glwb6rrBqtz8vPr3cBVRRPFWFP/1t30l/vKf+LJL7a+ZQJFFGv8+XDUuzLN08gQ6EExMoBGRGQs0ALc7C/SYQAYpDMDKwfROp9t9HNevhDHFBWznuH+WP0aVvAxrxDrAJiPZi2QMCyVZL4ysiy9FDmZlAoUmuQujkV1O7KDGeALxhVBb+3w6mF0mwcbqAjqjrGkanJzljxkTXoa1QAD0vqPAc+oln+eFRuFWjaFVRlxe1ULylX13mTHYt3z/rVSFTQcTT9EuTik52O4XCTaNCVm7+zueJ1CMXKsizMVjDOqbpgmyRfbB82kMtEwgMSJeudf+seOkx3SzLZZsOlhEkYNhG8W0r8jBYjwGgSFPIPfzEN+D68KyHPYKvZG5f48xhvbJxM/ePsKNS2oBq/3BY+cYeB/mWRJtbD1hPzAVgUZEF3tr0xdTps2JrUOo6mGJzYVzGIpZrDF0jEwoJ76jLGLn5cFZHmQCRcnByopgAkVQhyvOjwbQv59WDkYugGdpYh60fvMP7w+eK1oONmjTcsQAACAASURBVJInUJuMxKSDRTCNGHN06w5/WYeLEFafhpdWJaq6CXuJGJ9RQEkHS7HIUrkIVNVN8P72kaZ8DPp5XuEjnz+l+kcry6VpGo7tZTWG9imXbDqYkdHKSuZ2fXFUbPDISpIEiyxFbkkHaw3kh4+LZeUGN2RgX/yuyhpNM5zUGTMW7zO6iHiyCGSwKajItFcLc9kX+Iakfm37ERHr53n12IL6sfYjiiiMHCwmqKT/d5uK3pMx9Pj4b37ivQA2e4XOZ/aCvcePvPsDAICnbjwu1vH3/jfW82IrzvN60NdokoMdBqYi0IiwJncBXGILYJecscbNQMfAUAYutv2YHexH5wVuB30I3E9rOtitgTQS336MHIxiAlm9dKh0MPdT/X5UOViM99P9tXb5sjbao2MCaYPWamRPoHbxRbAgouRggV48RiZR19w77I7VzrFaS69uBBNb1tcSYwxNMEWO5mm7A8eiqJqN/gxXIRNkVT69442vuhU81toPsSmR6XqBrS7iC1Kq4p8hdazs5GAsW0pq/toxlFY4y5J2Ma6guwfjybWYFEEXEW/Dw3NnYjrkO7QPTK8x0LLtSE8gy6aeH1rDY4F+D15ebwaENtyAOP+5sm6Cm24J7O0zcrCYDQ3AvctJsvk+xMjlJnD46fd9BgDwzIbndWHclOzjhZdWAIBvfPOrHvvd133pXQAuSTIGy0EmUDoxgQ4EUxFoRFiTuwCf2BK+PVbJWedXMi4TiEkHs8fS5rhHswj0k6yKGjcCu1MxCwsmGSk6PS3wDMUasrJyMLeAsX0OvzB/1dNHV/7ef4crIxNoaGLYTQqlptd/43ftho+zLl7YAkfUDn9dB6U2VjZZSbIRYySd7OIFcPTuVakygTjGpodS8PPP51e95mmq3TF9qzpJntY+U2gF+jIJrX2NCRSXTnUdyMvNY0JmZFMyslcgXlI4ZvrY/VNXEB2SZ+9DkW8MqJ5A81beLxSByE0fCyPRpxSFGKFA7FjA2Ae4n5bH6DrkYL5/2FT0jimSTdBwtIFVNstSpEkcE+j+aY5vfeuzuHnFJvS9WzcAOCVBDIY8spwn0FQEOgRMRaARERNnWREyDMCeQGbzBBKYQLRfiZ0ae/+0wN2An0gnydPbdxHuYZaCVe73Lz/0Ij55cj54XBIREc+kg/n7Y118kTUgZGlqvs9+IbmZuuouIhe/qPd84sH678OeQDER7iEmkLXQ94HPvtT+/RCsCXNN06BuuHcY0N9jli0YM7FlFy+Ae77ORCZQSRbrPRR/JpbBAdjZXqHkPQ+r7xPrV2I18Pf9Oh0Rv8Pz2n/90fv43KNVKye4DKuvWk7Khax+LgDHBEoiWK2eFTdUKNiHIt8YYGXHHjODyXi9LqCEGHeW+RBzbz1i5P0lUbBv5d+GfqLrSwk5mLUINMAUBOwbMhN0DM3rYpk0J2c57m5iGhk9MPtomgb/4vdf2CjBnGfJZAx9IJiKQCPCEq3uwUh5LpxDfGG7lAGObZQkkKjoNV0Esu8+nufllZXyPvy818QEIjx7rAv493/6EQDgs4+WgfbjTARZLw51UqLIbIA4T6DzvEKaDBhDr434CnHQffFlR7l92+ue2XgM+/muAm/Ialt8feahKyB++aueItq37ZwC4zF1/PMQ2sHOIgq5dd0gTTi50GKmT9wYU+U+FDnYivCs8rB6AnWePWE5GKDfYyaBD7Cn5lRCMXrX5ULf/w9+dfD31j7UF8dH9Z+rG8qbzPr1n65ccfYqj4x++7t8f8dCXrriBuvP5/vbQkx7pQqtBl8mX3i/NXBv2/ZjNmUY36qI9ktClhdTxAKGmYJA3PVP4HBrLaH6k29+9cZjFrNUZqb3cbqqNr4P/v1VNz37yAMbTPMsjWp/wv5giogfETFFoKriIuKvgwkE6BPQtn1iAVwat2erhtt99MeqWBER7lYK/c1ASoVHTEQ869MA2OVg7PMT4wnkaaubFvJ+gakOWn4S/Oqnb2w8xmpY6/7GtxFeYNuKlO4EX/rKYc8Yq0zCv8MMkwnQ2WS+qBxaPMaysdhnNEv1WFTmHesjFZh9rIzHtTuuJ1DnPae1X5Cfwbq4YzcbgN2XCy3WE29f8LiMLE3kzR4AKEpfbCXGMrNhLcOysC9OvUxzyDx415leY6GoatoUGrClvdZkP2opxCnWBEnEhgDnkbgey/TmKVlerGdPEWACdUEWO9zR7Tnu3FzgT7/93uB9WETKqYYYX9vwHPJ/u6mQdWMyhj4YTEygEWEt0ADrHWbBE0hdYCvpYP48mpGgIoWhm33sHMH2IwZF5wkUjhSNSY4KYWw/F2uCnWoMPTNKGYBwtGu7sykOWuU6XW6IJWJlKLi/8QvU4eOsksKxd/jZhD8rm6xlAtGFSql59zd1Q7O55plWkF4WFZVQ2EeW8ve6EJlAMYk2YzEGQzuOXfvWfuji3w+eI4JVeR3w/nMvr642/JylqZEJVCFLE4qVa/16yjpskG5hiXi0JvID8uwYA/x9RlE1tB8Q0PN4VDyBCD8dwDbWlO1mANc+MJ4nUEz7jCwvJm0UCIeJTOlg46Osw16bFlaxR9M0yMsaNzaMmUmSuAj3mCJTgKE7eQIdDqYi0IiIiYMs65raGZkZi0AqE2iepvKkoX99m+BkZhFyJ3IBqfZnTdNQcrA0sRX5POPgzc8Om75aCwQAN+mxasg7TyCyiJjZ5WCnq2HZn6dfq4Muk8DXGjka9gbZ5CJroY/d4c/MBQJe0gkYJv+sJ9D641kW8OziBVizHYU+7rc/fgKAY+q058hSFGShSWECmdleFddPW+8xKwez9kNsQh6w+3KhN7ziJgDgu7/mdVf+3nkCWdLBGrKQaPcqqRlPIMQwgXyS4PACeIdv72hwrAGOWQx044W6qcd0o1FMIJJpBNiKKG7TZ5ygDNd+WA7mTx/jCTQcQe9+7nI/t+9gvDZjItY7mXyAaRTDBArMLeZZ2s4vJzzZmORgI8IPahbqKiszsBaaKnLy75GJ8bTd5DxchLAs7uq6QdPwC0iLX0ndhFkW1gW2Xxz9wHe+dbh9o1QIcJ/haE6yONQdeFLq5DEzLmAAl5RwdyAVpk07ET9DUTVCeprUNIBuosqwsUyGr8IOv9VPBxCKQMZCNMsSsUycq4bzsgDWBRph4uYXpv/uV7yS/pvjedayGkJQjKGtpritHIw0kFfvcTvZDEqR3E+1r/OfmWIC7bgc7DW3j1HXwHe+4+oi0CxNYPHqzMuaYopYjacBLh0siYiI93KwofE4TePMUvcVRVljITCBWmNoZT5H+AsCtmK0siFpnc8BrHm5+2mZcjFysNj0rrwcLujGyOUmcGDklzGeOszGyWIW59mTB1jG81mK8/PC3P6E/cHEBBoRXbS6ZfcuvGsBdPpudfL26bWprLJLrhgJasbQdLMt2iLTSHInNto4MS6wC2LC4Nu3Tswp+nPr52KTg7FWBM77yfY5Ts5y3NuQlAB0k1qdDcex7awL7C4dbJz22R1+q0xC9otRJ/8VJwOIloMJhqnKM1qQqUt9HM8znBdcAhnLogFiIuLDiTa+fXe8jQnEFvrU96CVHRNFoF2WC9V1g9/62P1B2auVCbQqOaZImtqZNJz/nF2O1zKBBj7HrjO9xkJR1YPsk8vwGx9KwaxqOFmtJchCCSmJ8XikJIsRTCNNDmZnAg3LwdzPQ3wPrguMAmERkQ7GjPux6WOhcyyyZJKDHQimItCIsCaqAIIG29NLxcn5b/6hkzLQch7RlJI3hjYaZ/v22R1s8RQ5MekE7H4rtEwixqeBMBe3sixUOdgsjYgHPi0GmUD+M6qDVlEpu5sGthrJUrD6YrE7/FaZBOvrZZ14skWmVpI3sjH0LE0ls1SWydTH8SLDORlDvxKKTPZ+yH8GrlisPqdFVSNNxiv0teMAyZrd1bXRb3/8BCdnxeAznolyRY+yYvsJu0yFTQeL9QQaGi+TxMaU2nc4TyBFkrrenJQj4sPHWVitChMoxuORLVQCdjlYlg6ntMV69iyLijSGtrU/IYySmDfOZylyY2fEMIBjmUChTe7JE+hwMBWBRkRMHCQbPdwygcRe/2ie4auf2xyNfdV5lF3yum6QJMwCMi6+mikyAfr3w9DPXftGORibmpNG+DQQC+Buga227f9+fE+g+6c57t3cXARKksS0QCqrOmhKDPgdbKlpAB37LPQdJcYEOH6H316IBoSIeNmc3kuRSNNg02fgn1GZCUSy+fo4mqU4LypqEeN36kN9EGBPdlr6fi5ogO9+6n4f4fvbb19dQPrLYdheMelUY+PR0lHv/8a3vXnjMbPMxgqtG+4dyCJZp2Ong82zYelrDNNonxHyibmMTg6mbeoxTB1LoU8JKbEWUZqmoQqVCexjTUGEBFj7OY+HZwXuDrCiY+RyEzgUdbioPo+wP2BUCDFMI4D0BDrEivoBYioCjYh24mwxhiYj4n2nr/uh1HjtM0f08TPRE6isOS8Oe6oNLzcDDHIwn0YyYEQJ2BNPQprctv0IijszcbMaIXZeHNzx1nSwZVHhvKgGmUCAnl4H+ELreKa7/m+YQpxNDlZTBYLYQisnA9C/o0KVgxl9jdj10Uw0v2elTn0creU+K2ICp7RvZbks16yk40ARKDP2ExWRUAjYWbOV0A/tslzIM7LuDCzwMmM6WNM0QUkq0LsHpvlKzXkCNcakzrIOjpVWf759R1FpnkCdHExjAjHPkEVyyQYEAPY5tRJUAtg9gYLzuQh1AADcP8txb2AuFGNsPSGMau1FGpRPG1mbQPdeDj1LMcbTQG99s8kTKLLINGF/MBWBRkSMqSy7QPWdkWzYGYiavIxM9ARiZRhWKUxNDupWFgHjQeDat01qFa+MMdPB/G/Vj6AUCAA3QbcsYE7OcgDDiyPA7bwo9HZgvXNHTJ4T2OnnQHiBajVkZeVg5uQo0jQYsElJ/GcO+2Ktjx/dGDqhk7sAoxxsXWxhJGH5mqXDeQLZJv7enyhUBPKLFzmAoOalWoC9H2LusfU9uA5438ChZ8laSK9ZP5cYA3aKCWSXquRlHWSrWf359h2MUW0faZogTcSIeLIftRSjK2Gcsc6p2bEsLn2sCXozxbTfNA1OTnPcHWBFTxHx48IXXkLPkbWvBjiVQEwEPXOOxWzyBDoUTEWgERGnLw5TS4Fu4qYusEMGc5cxT1PJE6iquCJQkhh3HkkmUGZcvChyMBPDZd3+kBEoYC+SAWvj45Em5rIczFisPF257+mpG8NBhiYmEJEOBqwntlLLDqwnkDkinnyHzcbW7Ts2DtuoIHeA/e+tn4E3htaYQBY5mF+sMRMs//1Q99jYT7RFoEA/ZGVjMZJU1353vIKWkUjLOndzdcT4QLg+Tp+Ys3Iwa6EP4Ex3rQlwgBuPw2PxYTIg3GaANpXPUk2CvCwqHAWKcG27I3oCWf3hWCZQjJxKkYNZ2n95VaKsm0EmUIx/3oQwSnLjyjIf9WBUArFyrZAnaUy62YT9wlQEGhGdKbFt8UIxaTIbhTsn6NUXziN2ahoTyLa76f6e9RPR2meZQNYijWcChCZWVuNsgCvEWSc9shzM4EMAuMknEGYqzLNUXiAp6WCWQqVWBLIygcZMjuJZFhbGGpsKE7O7yfaj7jo0NpmfSDGMTQ8/eWRYlUzksIc1+Wq5poUH5WDGfqKswzIhIN4Yet8j4v2EfmgRGcMEYt6A2PkKbfAut+7GY2ZD5hDXvjnBQLkMtb8+L2qqCGTph5R0sLZQaQwhGNMTiPFmsqYsAi4gA8DEBPoiws8PQs9qDBOo3RAY0xMosL6ZZ2mbfjrhycZUBBoRsXIwZoF3XUygWabtQtLpZkZT3G5QD7RvXLwwaSRAzOKLK25Yk6kAzlzcOulpmUDkAtvKyGKZChbT1IL13boGTyBLkYl9h6075FrykoWiz1GrY3ZPNTlYKklefR+kFNP95JEpNrG+YYB9Aezfr6D3mVEqxBpztywRtZDo3zGqCGQvqI+NkmB9WXeXG3Tf7xCsQRa06W6EX8mqqMPSbKMB/r6jKDVPIEBn7CzzKjhXAWz9kIUJZC0W055AWvMA1szikVIWAecHBAB3b22Wxsew7SaE4Yv1YSaQzb8N6BlDDzGBItPB8mpYaj4ZQx8OpiLQiIiVg7FMGss5CpFCrFa2K8UY2tCXVa2UJGwWCejfD1ukiVl8ZWkSHkwidjcpTyDjpEcxZAX6xUrtZrP3YZbqg9bpqsTNxbDMDAAQWUQJvQYx5uJMgSAxShalIpCB0VcS7Acgrph+tipx80Z48QKs08GEiVVRckWsPvyxzLOar6O9E7LAYVtce9krKwcTi8UEQwSwj2OdHCx8bExBfWy0XhMjMIEa0hOo9d5S7/H68DE9gVZlFSxU7vL9HRNO9i3KwcTNt/OiwlHg+wds/ZAtHUwda7QQAouc6mViPhEj1zrLSwAYPEdMkuaEMNhU31lq9/IMSbWA7TGBNnsCuSLTJCt88jEVgUZEzIDimED85Fl1opeZQGJyDs8Esu/wu+viFpB2BkrYh8AyMT/PaxzPs+ACLyYiXkkHU59RVurk0S7yxHGLlc3NxAU8sE7aeGo4dQzgP+Nl+O+UmXha7rHCBDIZXYqT8/Ei4t1Py6Tq/lkxSJ/vIxMTPZiF+2X4wjtTDFUku7Epi4zHAWAzZN0VOZhVenwd6AxHh5hA2hjsUZNsrK6P1iV//b/fhJhNsUkOthmK5NUjFRep50UVZOMCtn5IYwLZ5iutMTQdJCI1DwC4f5rjFYH5RIwczA8ZQ99TTKF1QhjsfDQTlRN9tF6AA2PBjVgmUIBttDDaN0zYP0xFoBHRdfj63/KTZ/dTWUQ2TYOi4uRmHqopJe1pZJyY+92jkBypM5XV2vdFoKBnj/H6z0mjxZhYY+YeWOnVjVgE6jyBtJeBlYNZpBIuaWM4dQyIl1OFPYHsEfFMkSDed4t9j7X2C7LIFONV8iAQqdvHPEuldLCibrDIUoqp4+E/K7OY//WPvkjLLc0JcKTHgXXxUpPx5FYZQyU+o7sqB2Mm/lGeQIwczOi3QpvuRiywXREo7J+3q0W+MVE3vCzbQ5Xvnuf8fEWd71YkI9S3D+ibSeyGQ4yc6uRsOLkLiPS3I+ZcMYXWCWHwzHT7WPOeT5wAGGYCzbO49K4VYQwNcAEWE/YbUxFoRMQkDSyLKjjpAdzk301u+Ze1Mz1WPYEEJhBpDJ0YJg1AV1hjzSjVDnlsOVhO7Gz69q200jHTwUoy2cnD6glEG0MbdskfLUvcPmKKQNYiSvf3Q7Cai7PG0FaZhHKP08S+eAxLFu0T50fnBXWPAW8MLTCBSs5YvI+OCRQ+z8lpgZeWJdWuVWbAehxYFxcVwUZ07dt2+P3hrOfNrhaB2mLcwH2w7i7XDUhJoZUJxL7H/npsBW8m3ntHb++oYEy5L0NNB2OKcICb8+p9EMckA+zPEM8Ecj8tc7pH5wVuH48nB2NkczFj5YQwxtyU9PjRX/gwgOExOda42bOINq1B2iJQOT1ITzqmItCIsE5sl0WFs7yid7BdEYhvf0UmwvRh8gSidmetcrk1E4hIXgL0SYOnfYajk22T2obcIY+JiKc8gdY/rfHerKTQamBO02/FQbeqG1R1Q11/Iu6aenSSuVD7tsVpXrJyMFuhUmFZuHOIE3NfgAiyUNxPSz/BfkeA2yUu64Y+T0GkwTx+Ds8ECnfYTdPge7/2eapd6w6zT+8KFQmsbKyqbijfMCvTSEmw22kmELFIte8uc/fAzAQSvb0aw9qlJgzeE6M0e9/h3jGVCaRtLlXEhlLbrjrfLTlpvG8fsMhGuUJTjHl5UTVYZGHmuGtfbr6d4w/LwbBu//Deg+vAdTCBPIbmLX6uYkVIDuaTyaaY+CcfUxFoRFgHrAdn4SjIPtwOJ/+ystXsC+cQjXfHTgejKejGxUsrByMMU03XL5h1WgeTktgh7DyBtLZ9ugC7CLang3EFy7m4S16QBn+A+44scypWThXD4tiddDDd4L31EiF2+IGIiTlZBJp7qRb5jBa1JqkFOtlVqC99aVng0w+X9LVbJ/8lm5BnfH/pzQDjWKlIFtM0wa4GnhSECbh1d7luSE8gYyGuZQKR3l6NIXupqsNsJksh+kmAe8e0v1ELoqw9gUWWep5zfkOAnV3PMoH8b63s7lB/bbFv8GDk5TE+pBPC4DclbUWaVVm1/z3EoI0tMuWlK+pukpEu2gCLqQj0pGMqAo0IqxTpwbmLgrxD+JUAvkPg2z8nq9mPn0P0BKLTwSIWqES6FqAvLpaF81sJae09y0I3ViZ3r40T27pu0DTh9DTr4tHTRHmWhbUI5NOLAmkMmSYHY2I4PayePV06GPeMqt/NipSDWWUSanSvOrFVzTrV+UjTNOuELZ4JBPAm+y5hUZWD+ULT8If57v/lXwLg4+etO9isN5x5B74JR4cDQGJc3NXkOwbEJbaMjbIKJzzFeAJRbCyjf951eAI1TbjQkR2qHIx8x/pQN69YyZllw+G84OLngYhCJSlttsrj/VgTLgLZNzSYTRmrZ9IEDsv1vDGUlGftq//3X/lo+99D70SM3AwIFywnT6DDwVQEGhFWFkq7wGaTYcQCDVvN7kP2BBKYQDZqLCcDsBbiSsKDwLVvmzSwZp1WplG7wA58BisTaFXxRRSgK0apA9dyHU3LGICPxgSCzVPH/0lw4mmkiBcV5yuVGJlANbm4A2wG6XxE/Pp6xPZDuvfL8AUa1hzaJgfjCk0f+cIpAL7Iavb2qrl+LjMuXliWgvX6We85f45dTTtxxbhQH2fbXa4bUKZJ5rHyGtLBaoI5m6aHKYOxMoE0OVgT3HADfCFOLwLdIOLnATujmJ0PWZlGnbE7W2SysceB4fcsxndrQhjehyc07rukUb2A8rEvnLX//cwACSCaCRQoWE5FoMPBVAQaEdaJbZuaQ+4yz0STv9PcmY0qcrAxPYFioo1ZOZglUnSsdDZ/PQxFPzV6ArFSHitFP6QpvgzrDt55zu0SzjPN1Fe5fscEoptu0dG3Q+3bFtg5yUSxegKV7fWPw+hjmUaZ8R1mEpf6UJK7fPsqE8ifg51c8RHx7qdl8UIZN68PMcnBhAKEzAQiGZXAeqzZ2SJQuKBonfg3JBNo7HSwGL8VRtJmTcjbd7DvWB+q1yDPBNJlwUtyjAc0Y/0+Ok+gUDqYcSwmN5VimDo1MV7GsO0mhFG2a7Nx+mqm0OqPs0bQA2sm0MBn8O9ZPhlDP/GYikAjIsanAeD9VlKhw6nqBt/3Y78KAHjqhuYJpCyy2R3a1GiK6wdERq4F2BYvileGLmNgF9e2hUtJxm9bJw0KkwaISwdjJojqLrnqCRRnDD3ODnlB0M99+1FMIGYH2FCs9GajjNeHO15rP2937chiesvSCZ/o7/38H+Cn3/cZmQnk2Zfv/t3PUceTJBe7MXTFFxJd+2qRhh8HAL0AUdccoxJwHgsWVuV1oCRkedbd5YYooADjp4NZN8X8NYU+glW2u++o60aOiE8E+W7TNOtNsXFYp+cFFz8PdM+Y+h50IQSBQuL6pzwfIhki/hmOYXcPFfz8LTrE9+A6UJDPUSYqJ9q/IwezWCbQKiAHW8zcdUzG0E8+piLQiIiZmAOcDMMfx3YI3t3+ja+8hXc8f4e+JtV4l5aDpXEshdB3ZPUEYnX2MTIGKtbYILMBBFNfq9RGXWCbjaErHBGMtbkoB8vJSRtgi70FBAq64RmtazcxD6WR+PbHZNsBtsl/WY3LtmvZXkS0MdCXg4XP83f/2Qela/H48lfdWl8TN/SynzkmOpkt8gH6DjZ/j439KDnOANpmyXWDiUAf2xMongk0jv+c/xumyHSIMpiqMUTEC8xNfxjLBJKZ79UwK6GPmdBH98Ezo/3vx2ECWVmtQI8JNNBPTEygcdGuzcZiApHvsQ/qsRb7Jk+gCR5TEWhEtBNzsTNo42JpKQBfdfYLo7/4x94g7WKraRKKDMBU5CBTYayGoxWbmmOc2NJyMCNTSjXdtUzc0oR/RjPSEPcyeCaQKAe7Bk+goi3mBhZHBjaZv/75jCnQxEkKaTmYoQDB9EFJksjG9ED3/fOFSp4J5KF+5iRJ8OztG22sdgjspbTvsThnK6oac6rY7X7K/Sjdz63bFx9USQ6W7G6EOJM0Z91ddv5zAhtrJNPdrlApNd/+TZhReZhysNLABFLmc6znE2DzZSoqrhANoO2rKpUJNOKGDMBvKsUUado572A6GNbtH+CLcA1gnyPPTB+LkTVL7c8R4JhANwY2x9oiUDkVgZ50TEWgEZEZFndAtwjhZQz8gN4tjNRo42S3IuLJiafV0JT3BLJNnOuGj96O8aNh08HUwYqJQ+3D7AlEFoHmmSYH61gipCcQ3XKHTtZJysGU6xeMua2SQnaHH/A7y1r77/7dz9LHpoY0jJVwj4HeLjPRz7UpX4bM8Uzo81ipU4z0WDHAt8i1lH5UfUxZg33A9YU7WwQi/L3sTKBO5jIEK9uLZVl0IQTWQtbwMVYD/H1HbfAEUor2rOeTb1dPieQN9rvNJCsTiIxwF9tnQwis7QM9j76BU8T4bk0Io5ODhZlAgKGYSBY3W1mk0RcoZAztf7eamEBPPKYi0Iiw+62QUp41lF0ddWHkMcu0CbRSBGoam3EzwNN71b6sIlNzrMlOdGxvEqcfD5p1wnb9L61K3FrM6OPNcrC8ogzMVb+Ml1fOHJ35DPaIdY46nBmeIaWIFSspZNKHFY8Jj3ma0tc1SxOaPeOh3GMA7c5YTux++cKYuPYC4BYyoaLc6+/dBAB879c+T7Vp9SZjF2BdgWCcYrpVzqbIwbJ0d5lAZR2OiDfvLhMsGqArbKo+EGyQRYwnEONrZN0w2XcoCXkeGhOIn49axsqSZF0D3eJb2ZB0x3MWC9YiCrthEmWOzngCTUWgUdHJwUJMIFuRo1JoUwAAIABJREFUxjNvfuKv/rHB43xfbR3P8rLCjYFxf2Yc7yfsH/hV3AQZdp8Gja2j7BCqscn9c0ieQKIhqKP189fjv9Ow1Obi8SzUdDB1Yl43oCj65gU8WUi0Xv/JaY57txb08VZj6POixiueCheBZqJU4v5pDgDUZ7DuMPuJKjvxVL6bQmICGeVg5DsGuPtrKeR+21ufpY7NDEygE3+Pn+KeU19sPF/7pg1hliVAAdwUCqEeGSHfffb2DTx35xhf/qqnqDYT44ZDXjWUpDOGqcMVgRLTe8a2D6wXvju6OCqqBvPAmNzfXVbHypCRKYCWcbkknv8+SjKFL0aqUtXhTROrtHyfUdcNGpJV3EeaJmDrKBU5jgE2c24mGc+jm0doi2uWrRbLhgt9RZ0nkNZ+/xxD43HHKtbbnxBGa9URuNHWTc+8qvGGV9zE13/pvcHjPKPNIg8G3EbX0NzFqnCYsH+YmEAjwlqVL4VBF+hMwhhY5WCq54oSEQ/YijT9v98Ea+KJEokK6IsjNrY3MchsgD4LJcShdz/U679/muPuTb4INDPSuFlPoLmYXnciFYH0AgfA0+gthTiFCWQtYqk7wLqXSE17Ss0MxdCTs/U9Jp9TZRHsF7xstHEf6boY8QsfeAEf/vzLVx6j+GQA9mJuUdZYKHIwQz/Ke/bo95j1uwF8fPVuTmqdN9M4u8s16cvUFkFzrQjEzili/FAmY+irwfjEXAWlWNOOA/SGgz6Xoz2BBMnu5XP0/34T/EeUZa8+CZQc68di5k5MoHFRVlyiaddXi0WgQHS7R1tkMsjRgbAcbHqODgdTEWhEZMYChFqomWe8aWq7eDR4AilUdLaIYmFBAD1qbIhCb01oq9l0MPfTsjiiI+JHTAdrKfqi681LyxJPH/EsCOsi8uVViVs3CDmYmF53clYgSYBnjufBY92EmW66RUtBD8nBDM+olG6WJCZTI2++yab8ybLXuqF9z7wURoFne90lGWu+oMMsgp9fy7X+wrteL10T0CXz/KV/9Bv4lh/5pSuPqUjTbA+79FiTg6lFJim9a2QpiR/DdhGMN5N1d5llnbbPv8gEykmJhJUZ7f4m/BmsGyb7jK4wIMrBhKK94gmUJIksvXfvMNfXJUmyZoVamUBhyaU7Xiy0rg9nJIv961HAhKGkbT8tNz+BAFuwtBZp1PE4hgk0tAbsGHem5ifsESY52IgwR8STDvQeilSiLTAZPIEAnorOFjms9Nh2dyo4MVxfj2HxQjGBjIujuuESPaxysLHTwRQzR3cdfnLFn6hpGpyc5rhDMDnm4gLv5CzHM8dzwefAfg/CxtDrAdeQDsYaW9sS+NxPVhZpMcBnJ/8WT6CTsxxZmuA2Waw8XrhrYRbBz985xumqxPf8keekawI4P45ivePIwrrDXFQ1bt1gfLHcT0s/yhaBLIy1IrCj2Uea7i4TKK9qPD0fvg/WiX/TNJQx9NHocjDbWOn/Jiy1Obyd604Wb5CD0Z5A/GZAllrlYPz1W6TB7HyoC7CQmm/vQ5CZvgU52GARKKLQOiEMNk3Ts+YsYRbMeGbdEPAIBbtYGXET9g8TE2hEWOPJW/MxcoGkSGFWRiaQH3gKcnSsyIq5fXGxnpgEdx8TUzqSmg6me2WE9eNAF+9t2YEHwjtfZt8qVa6yvgxlUPz0wyXKuqHkPJkoB7t/mtMyIcAmYWDf49bUVziJlm5mjYgXmEAWGYDwDFkm/vdPC9y9OaflQkcCE0It0vTBFIFKkQlkNRwtKu48qXHSWZHFbsBm7JsrfiLGJMrrAFNUb3dnxWJoA26s8XIwtQjEMpdjIuIrQtJ2iHIwRbLbhyK9VNPBxpSDAesNH/EdYMcyP1Rb+jkgzFbbhhyMM4aWm59AgJ2zWIs07KZGdDpYoAhktdGYsH+YikAjwsqyaGMIpQWSKAczGEMDfKfGy51sixdfixprYlLV3CLPOqg3pE9DZmbqkDtTib8erf3iGphAP/LuDwAAnrt7HDx2LsrBHp4XeOZmWAoG2FNn2PfY8gwV5O474AuJlkmn+8m8B5aIeOUZmgmSV4+H5zkl9/NQmBBqkaYPxqA4JyLD+7CPNTUWs/H6oZpkVAK67xzAeygAbsNgV40uyyosjZy1E38D65QYa5QiaB8FKQeLSQeriflEYix27zP8Io25v33sUjpYITBCAT2p1p2DK2T567DM54AwMz2mSFNUNZJk+D7ESC4nhOHG5fGKNLQnUGw6WKDYZA1ymbB/mIpAI8LKcmGjpT2UZCRl8XjxHBq9UU4Hkz116gt/P3gOYtF1GWXFp9q461En5uS1G5+hzvtp2E/HyiBQvDiA3qAinMcvCL/9ba+h2lcWkGd5RUeHpwaKO+De44wwEbRMDDUmkJV+zjOBLBHxyjNkYQLlZYPFjDdubhfZxHNUVLW0e91HmiTBGPqTM04G2bXpflrkVLSvFPR+rlSMoVO90JdXDb2hofigXDdywiQ9MxTSAedXwrDhrEUmdk4Rw4LgIuL9sbt5j8dAbpT3K+lgtVAEskg6mQJoH7M0oRnpHnw62Pqa5Pmo+xkuVK6PNzyjD84KPHM8zGyNkVxOCOPkjAtEiUkH45hA7hjVIN1jFSg2TcbQh4OpCDQirC8Su2vhIUXEXxMTiC2itJGcYl+jUJQzA5ODlbNZd8irugGzNmqlQobFHRBmofjfWthqbJESsEW7VnWDL3/VLUpOMstSybj8PK/ane8QzJ5AZJHDco/zyu3Wswv4qHQw0ttLmXg2TbOWAQieQHIBQveaALg+rqwayhvgKszSZJBtUVQ1XlqWVHKdh90YmpWDuZ9yak7Ny8HmWdJG8LLIy4pnAhk2A64L7nlimUCWdLDwcTFmpgAjB7MvLJjPcIhSmM6PSStIu40BkQlEMrvVDT2mANrHLNMZg53PJplgZ2DbAcPJXUB/vqg/pCdnYQn7Ib4D14kHZwXu3gqzi63+bUXZaOlgEZ5AN4bkYMZ1x4T9w1QEGhHWAaVsZSTs5NYSEa/Th921cRPQuuF2gFumi9Hoj1lgpImtfY5l5H5a6MMaU0pqni72WdPB1AV2N2jx51BMZefioLgsqtYDI4QEVvo2ucD2O+SSJxDP6LMaQ9frQiX3jmkygNY0m2YC6elgKlvNSwGY85S1nQn02UdL/M7HH2z8/YOzAgCfagbYZQCsp05brDd4ZfCbGSk9vniEvA36cIXK3fQ5YBhZ3T3Q2m4aUBsO5oXLdcjBGj5+e1fZXmOgEP0jPSzpYHyQBX8dH/3CKaq6kZ6JmWEs8JtPrBzMmlbLpoNZ+iDHDh0uQEzG0OPi5CzHnWOGCWR7jvKqplh9MZ5ATdOE5WBGg/QJ+4epCDQiLAtfwL3YIe1vH6aIeJEJ5Bf8tByMNYZu0xK0zvLRuYv4fopJtkl1JoRapJF3yEk5WGYsMq3EIpA6liixrkDfWFZgApFeFkBnEM4+n+dFheM5H0trmVKtygpHxDlMEfFCOpjVK0OR8iRiodUXusdkAhXiDrPCVluVNc0ku4xPnpwP/v7kzEXbK8blVhlAUdUUi8BaIKhqPr7assNfiHIwYDcTTxhm5SyzTfwbcP2oNX67IDetokxxmzBzNjFuaOwzrGmvSjpYm3xFPUPa/f3MA9cXvuW1T9N/MxP9/wDe18hqDO0PD7YfwdQ5XVV46mi4CJREtD8hDDfuC0WakTzu5hGeQEXliq6DcrApHexgMBWBRoRl4QusGQTCAlvxQ1kJi8eL59Aq26oxtNrZnJwVuKNEfI/m2WNbfLEUfev34yeHoQHFyiBQY10tfhO1kBoyF1gcgC8CsXIwG337vOAkZxZfqUJI+bM+owoTS5WDFbXGSLTGAo/1jJ7n/POj4v6pKwLdJY3LgQg5GGl02b5fshdHTRcS51lqkIPx/ZA14ew6UNbhYpzVrJMdy/w5rEwgfqyRmgew3pQh/VYOad1SGOVglnSwUBIroIco+HnN6+6Ewx88ZpZ0MNJiweJd2D8+NFxaE4OBNXs5UIA4RF+s64SbE40n18rZoAZxvnv5HMDwGrDdmNzBsXLCdsE5o04wY2aYVFWi1EA5h7J4vHwOQIiIJ2UAFhYEANwnDdoAnaLsrkcr0ujtc2ad7QJ+JDlYO3HWmpdjXS1yEtVUFuAWqSenOR6cFTSTw5qutSQLTZYdcoUJlPYWX8paoap5KU8qxm+XJt8zcfe3qjEjmIIeaZrQjCa2wGfBiS8CSZ5A7qcpIp54hmYi085DKSS6xZ1qDF3T5t/+WdtFqURRhllrlkJ6UdX40AsvU7vXgJNnyp5AJScHi/ME4qU2O3h7R4NZDiYwgZhocg9VetxKzYR0s3mWjsYEygwbMkDPEyjwObKId4AZcyZD33FRkqnBvmBajJUOFrGh4dcGQ55AUzrY4WBiAo0MZbD1KFQvCyEyU1k8XjyH1ilUFWcI2u4Oit/R2arEzRs8k8Mi1+KKNP54XUPOFZncTzMTKFQEgs4SaZpmXSAQ2GqJgQnUaKaybPsf/NxLAEAb76aJLpcD1mwRwnfID7jKLX55WQIA9Q5YTf5KwdQ3FSPiu91l3s/FIhVS+lGAl50tC07qZ8Fp7kyj2fQ6oLfAFu6B9wagmECZLY2kbnhZ8yzjve08VkU1OJntwyppuw4URFHdkg72bz/1cP3zEXV8DBMo9K7FeQIxxtDdsYeCGDkYe5vZZC1gvRkgjvFs2x6WsYBN6syMY6XsCWR4RBn26WQMPS6quqEYce2Gg6Ev5dLBbHIzoL9BvPlZiinYT9gvTEWgkWFNtZHSElI+MtPv2rGm0/1zuGsji0AsEyhigcoWIRxFWWu/IZlA9oh4Ti5n/X7a6NiQT0NLT+bb7jwghImbQcNcSUwgL1cJt+8Lau94/g7VtvMEGk8OZpH83T/LMc8SPE0wXaySv1ow9VV3gLudU+74WWbtR0WZBNlfb0sOdpWnmWfDKNduWQD7vlzyBBKZOn7xxWBm8KPRZJ27S3F33kzbZwLdEphwgLah5FHULtEmtMC2SlWaplmbWweYRji8hYtlLAa0/roSCjVKcQnoitZKrX5mkI2WJKvVurhmPYHaiHhDH8TMJ6xj/QQO8nNkkjdfDxNoUA62w6zZCdvFVAQaGSYvC5kJJETEV850Wt0hVxbZAM8iSI1FFMWTRt2dAvQijdpXsiyXxLhwkdPBhOb9Qk0tVAKiebAiJfH0W2KR6iee7CLbTZipQy/gvODMgy1MnZPTHHduLjRJofgZlO9fjaFn6fMe5nQwudgdPk/TNK74QKbLDeHlVYnTVYmXlgV+4jc/AQDtAkcrAun3mI32BnpyYDk1h7/HlkKfch92leLu05FCmxqKcbmHOok3GUOXXLE1Rjrtr20IVmnzPkN5h/uwpINxTCCtyFeJ4wCwliyKz2hFzqmtrFn/HYU+htWfDwBWRR3s6w5REnmdqCpuTjQT10uAm+OXNRd0EJMOlleOaTylg00AJk+g0WHaWSOjpdtzpCnNBPKaU2bxePEcWqdTkyyObtCVLgel8B3ZPIFYY2h/vLq7yaaD2b6fnDXrXP9Urr8Q/VyA7rOqxtCsbFFJS/DPMDvxTJCgUU2ZACzzCq+5fSN4XPsMCd/NS6sSTx9x3bf1GWUnPIBjemlSv/XfsQUCE6OyoSPoPRgmUFE1qJthTf0Q/uM/+gb8X7/2sfb/f/Cfvh/LosJPvfczeMtrb7dsGyUcoGP0Ce9x6YtNXMKcxbNHiYifC+MY4BZSS7LQCuxuEYiNWG/HYGFh4Y99wytuUsdbTHeZeHsgjpEIEKa7Rv+8fYa1CJSmfFiG4tuTJeI4IBSY2nOkiSwbZTc0rAyLhmRLWedzdb2O9WYT+Hasj3tSwDKBLEmOilWHNYIe6CUHE+lgExPoycfEBBoZtlQb3RhaYQKpptCA7gnEdpZWijjjoeCRJPqgWBORtEDM7ua4nkA5aQDexeryKA0TT4tGumqUdCqflkAwgUQfgjS17ayxUhWLOTq7swnYn1G3gOfu8SLTFvD+OWBr0TZGpSarBThJku8D1bY9/tb3vP3C/3/sxVN8ah2VvCrrzjRbGAMsGv6uUMwzdZR74L3DxoqI95NZVg5mTf4ZG2y6lqWI5e/XD/77b6WOt7CxiprbkLGa1vrjabnZAXGBrHKwTDDy998/M97MxXFAkZr1z6GnFHKsUMtmFcAzmqwbMv56Qvd58gQaF2o6mDKesRu3QPe+qMVQgDSGNio0JuwfJibQyLCk2nzsxTNtZ0SYnOclZzz22DmETqc1yVPkYOqgSO4+Ap4JNA5Tx6rx5plGNjlYUbkUg9A9sBThynYRrO3e9f+WQS3IkeZC+37+qBRRrGkejFTFsoCvSLmitX0A6wU8d+wiS9vJBQO1EGfpR93idAQmkJdDiiyjTXjvJx+2bJYsTdr2lSKrZfKvsghUpo7M9srS1hSbwfn62FBssseuTmzZhbwloa31lyJfZEYOeRlFyUmz/RFqV+qPH9N0d18RwwRiX2W/kGX66sVMGwcs6WA2fzhuLmFJMQW6Zy70Oazy/k6Sx6W9TgyOccCmg80MEe4FaeEA6JvyfSieQLs2Vk7YPiYm0Miw7GC/5xMPcLbiJ8NSRLxQPLl4Dp5+WAk7R12RQ7sexTfJxVdr7bNMnc4TyLDAVopABiaQsjurdPaFQa6SJIlsHmyLiGeKQKIcLNHlhICTgzFSFcuAWwlMuLbQJ75jSgLcYqYlO6mTf0s/yr4DfTBymEpYFDFYlTUenhft/5cmuaX7qck6tQWkytTpGFN8IVfZ4V+Wboy8ITKBLEl/Y6JlVgYm/5Z0sEJkldnSTMmxJtJvJSwHg6n9fYbZEyjlvyfFv20xc0VEtsjhL0HpS2cWOVhFRnsbNyVr8hkFbPYEJbnxkCQJksTmOTRhGHXd0GmXMXIw5l2O8QTqNh02n2d6jg4HUxFoZFi8LADgG7/yVcI50rW5ZPg8ViaQ0qm1kzZBDqZO3IqaX+CpxQd/PVqRRmoey6LC8YKZOPvr0dpn77Ntd1lnAgH6LrMiJekirJnn0/1kJ54JbIMhKwdTTK09lOQ0ayHRFSq5Y+cyE2h9bRITSGNAPFoWuHNzQf8N4FiVofN0TDj78PnbP/CteMfzzzzedlW3RQFVIgF0u4kM2skgOR7MslSadOrm3+o91opxMRPnMZGTRXVLOlgpssqUpFEPlnHXsU6l5mnJUCttPqB1S5QcjPYEWv8NKQcDumc63DZfPPFw8wiLHIx4RlO3+LUEiQC8eba1EMq1b9u0mjAMZXPbsrHnPfoYOdg8whOoC3YJMyt3TTo9YfuYikAjQ93B9hOw5+4e03+jTA7zylgEEjq1dgdYod/KcjCFCcGbIHrUddiDALDvPrIFAjMTiDTOVoonHpZ0MMAVtJRBq274QodSzFJ9CNJET5wpqhpl3VD32A/6UpIEmS4HxPgQ1BITyCIHYyf/WZpK38/D8wJNA9y7Oaf/BuAKlUr/tgn3bi2uLI7kZd0uqhXzft+ns4svoO9FwzN1lB34sl24cMerRSD1PliZKGOjK8YNfw5LOpjKKjMxgUjGnVmWShb7rP6C+wwrEygRJM5+vGfGS+8zws4nLOlgaggB4D0qedmo+g4ozFYLs1hhVVqKTBPCULwA54Z0MCa1yyMzbN56tAXFwLPq3gO5+Ql7hskTaGTM0rSdxDBYFt7ngI8f9p1SVTcI/VleasljHoonUCkMiNaIeEfvHdMTiDVu1jXebcS0UgQySGGY9KK5oQDRLlrERbBnrLGo6qYd7Ji23bUxTCCNaWHxBDpb+5UwcjALE0iRQyZGtlpV89/RIkuQVzWapqGKF+3O6UjpYCdnTl5195bIBGI8gQxMnavw3N1jvOcTDy7829/4iX+DzzxcSv0/0BUSlUKcLgfTDFlZHwuPLNV2HtVibreRQZ/iWsAa7VuYQKZ7rI41rBzMyNShmUCw9XP7DM/80+Vg/MaYwnKZi/2QJR1sTkh2L6MS/AVTsR8Cer5VO8AEssrXJwyjFDYdMoMcbCW8y9YUu/7fBIvqgmR0wv5iYgKNDJUJdL4uAh0RhrIe18EE8ovZVRn2KqqFztIaEa+YviaGijZr3GyJ/FyVNZqGu8fWSNGCvM/WAkT/2likIs1akTz5Z4HzBHI/2bZduhx1aItHa4+XZwgmikqhBzRj6G7xpU48a74I1O4AsxIDdxzLdlF3f30/xcaHeyjpYKoE4zL+9p/9anzDl9678G+febh01yG2rX7/7lhtAXk0T9uJKoN2gUezvbRCX+fDob0HuyoHC21qxKSDsc+TRb7+6LzA7ePwfqKVkcje55YJdEDpYGxq1GUoBVdlvFQZiZZ0MLUYDfCGvoB7B2TjZoHZmhmY6UoBIk0Oiw13XVC8AJWgEg8/djObt5agFQ+2qGthxE3YP0xFoJHhkgyEanChxd4CfVPc8HmKsqbp/3346/FMpSGUwq6FWapS1YLZpT4oOrlN+DjL9StsL9++2hnnZGLLPDUsHg3pRYDuKaJExHs2HBUR33pWcdeRJIm8rDg5ywEA9whPGgt1WElO655RunkAQNXwk3NVVqgagqrpYBZzZX89rCcQy3DZhKeP5vgvvuVNV/5OfbdaJlDFBwrkpV9Acuc6nmftJgUDdYEny8EEj4b+dexYDajtexcBOdjM0E8UZIHJIyOKoJfx4KzAXaKfs/rnsff5ENPBFDPZPpxEnju2LeYy84nWm4xlGXXXw0IJQvFQmEBZorevMFstnj0Kq9KaZjphGKyXDqAFlXgwqV0eLRPIQGtl12ep0c92wn6BGjmSJPn2JEk+kCTJh5Ik+e83HPNNSZK8J0mS9ydJ8kvbvcz9hZUJpBSB5oI+1MoE8tdzTkT4tn4fDG3SKHdychjWGFqn99YN6wm07oyF9lu216ieQNx9nkcwgVS2glvk8cfXNT859IOiIlfknx+9iHj/1BWBGDmS9wKRjKGFApndGFpnArEyANUQVO1HlUJ0H8wCg01qYbDpHVWv25s7s4svoOcJFCg+eBzNM6r/95DlYOLOo++HFHNxQE/+GRusHMwvwi3fEcsUYdLxLuP+WY57guzS4v8HEPfZF7sPaOHyv/7yRwDY0sHY96DtSyUmENdPKKlaHjODJ1ChpMkamED+eNZHUvfnU5hAkxxsDCi+T6aIeFM6mF0OFvocWZpMjLIDQPBpS5IkA/CjAP4MgLcC+A+TJHnrpWPuAPj7AL6raZq3Afi+Ea51L6HSq72M5Kkj3q4pE3YI87Km3Ocv43gtXTovCLaRECFuKaIAwKriPG+AdRFI7CxZTyBLEaut+As+CpZJA1PkUFhkbdvi7nJ7rkRjc7joYY2JQsnB2iIldx2WnbXTlZsEP3Uj/B5bzLmVnU2reXlR8ZLLW+vP+fKqpI5XCsWA3o92ki3dKyPIBNpiRHz/+32696yoflu+L1kZjKFpJtAio5igHl0RiDt+RiSz9aH6SvlnTemDrgOsHCwmHYw18VeLrYDbGDompM1WTyD2PitskicF3vtM7YukdDBhvFy0m0qs1MwgB0t1OZgyXs4MnkC5Z/MxczqDR6XiY2gpMk0Io6j5ezzL9LFGYwLpRSaPWmBW7tqGyYTtg5kZfAOADzVN85GmaXIA/xjAd1865i8A+H+bpvk4ADRN88J2L3N/oU6q/KDOyEg8lPj2gjRxvAxfcGHkAMoiyR+j9DVV3SAva2riCXgmB98+wEfEW3walImP1ROorrkiVpIkWGRpO8AxiPIhEOZuZc0nwCnvQOdVwhdRLJ5MADegWyR5loh49R3IydQfoOuvPAMqBFUGkBGpXX1YYtYBv8AYPs+2PIGA7vre8trbeN/f/NP4H7/T7a+wfZuHysQCDEUgVQ5m8Owx9aOsLLgNIaBPcS1g5WCWdDDVxH+eaeb9AJ/i6IsIujcZN176304L4DCSdkwIf1edxyOzqaRFV6ubAe46LOlgNV0Itchglq2XJ/EdGTaVVCbQ9ApsH60JO8GcVYJ0PDpj6HHWHR7s+iyd0sEOAkyv+ByAT/T+/5Prf+vjKwHcTZLkF5Mk+a0kSf7iti5w36EmIv2rD38BAHD3Fh9t3O4QskwggxzMFwt+7SMvBo9VtLMWzxs1Qc0Se6saQ1t2sJmJT2L4fvzxvJ9O0g5wDKwR8Zns68InwCmFFFUOliQ6LVbZ1THJwWohIn59CbKkkEyYAzrZ2/0ztgikyQBUJlBcoZKTg8V6AgEdY8yzgHzxRy4CGdhkeSsVGqcIpKQK+eOkdDCxmOtv1675HIyZDtayNkdkArFjjdkTiPawcD+nBXAYyrxFkYOpz6j6DgPeGFp/RmnvMANz/DyvkCYcS8SS3qVsrKbJ7vVxTwKUTRN/jHIffPvMnEtZ810Gu/7I0sOS1h4qGM3RVU/K5SdjBuBrAXwLgGMAv5okya81TfPBCw0lyV8B8FcA4PWvf71+tXsIdVL1sRfPAACvevqGdA5A8AQyMIH8337+pVXwuEJYXHTpYIYiELlQSgw7L3XTgJmXWHwmlLSNjiklTnqE9Ki5GAucCzsWfag7eGXNy5FaJhCxCFaNoS0a+1XFf0dWORjtcWBcfLEJcwDwzDod6KUlKQcTJ/++OFOTxS/Vj8ZjliXBBESr6fRVePNrngYA/Off/BUAgDe9+iksZim+9S2vkdppvb0UJpAgSwWAG/MM57lSLDYUgUQ2nNL+TGQpXBdY8+brSwfj73HTNPSGiTUEgjUYt0qnDxFZb94SWgQo46XKVrOkg80z3by8rBsczZWxRmoey6LC8TyjPIHSRF9cV8J7PBlDjwPFhN0/zopssbOJIKS1aYIksUmb/SWF5i/ZJAc7CDBFoE8C+JLe/z8P4NNXHPOFpmlOAZwmSfLLAN4J4EIRqGmaHwfw4wDwdV/3dQfxdKmTqqpu8M7nn8GNmZ4OxnT8ViZfFVtPAAAgAElEQVQQAPzZf+c5/OuP3g8e1w5Y0u4g/zgoxsqAT3vQOstmRCaQ4pWRJnr7gJtksPd5niVSPPly7Qt1c8H7VgHuu1Luc1k19A52G3VPfE/qxNMSm+wX2DeIAV0xtfaoGp4JlBgXR7kgHe2Si7TJPxsR30ag1zVupOHvtFtYb58JpPRvIdy7tcAf/u3vaP//6770Hj74P/0ZuZ3+oo5Fu7NJGkMfzzVPoFotAomTzi6WmV3cXfy7XUFOysFsZqNeDiYwgZSUwqb7uxCs/ZAqK9yxGt+oeO7OMd71Zffkv2vnXUR33aWzbZ+h4B8Fxc7JzSNAbwgAIhNInLMDbk7K2xPY5WBUOlg6GUOPAcXLM0kSedNTHY/nokTewz/bof7UYpA+Yf/AzAx+A8CbkiR5Y5IkCwB/HsA/vXTMTwL440mSzJIkuQngXQB+b7uXup9QJ1WKdtljJhQirOlgAL8IkFzuhcmIh0UOJnvqsMbQBlpmLSxeYmJ1lR1yZcfikyeOraYk2AH6u1DUNe9lIRQhVAaBxVg8Fwb0JEkwzxKJCVRLnkDup0XSxrJEOiaWNvmn08d8BLqYPqYm2HHpYLa2x0SSJPIOs24MneK8qOjnqC22skUaMfVHvcfdwne3JrZ0OpiFCdTKwcZhhSp9qdkY2jNnSSbQ40T1JxesH9NlKAXRtggnMYHGk4O1zFlh0vjx+2d8SmGaQFXZnBcVvylpmI9qG6v6WD8hDEXhAOhBB37OyM65LDYXAN9nq/LsCfuJ4FZ+0zRlkiR/DcDPAcgA/MOmad6fJMlfXf/+x5qm+b0kSX4WwHsB1AD+t6Zp/u2YF74vUDsCJcrSQ2GLFILZ62UckxHByiKp9byR5GC8dtafw2J2KTGBLF4W5IDur0cBS9EHXKFCKc788Lsdwe9ornsCsZ+jqhs0De9loRQhWPlF23YEE4guoqTp6BHxKsVdkYOpE3M1Il41Pi6ESXMf1+0JtE2o0uNcZIkczzNUdYOiaqhYeTVFLUu0nUeVIbLzcjDWE0gqpGvvgbqwqFtGX/hYi/8f0POgo+VgUvN7DcX7rw9lzqgUarqABrEIJBpD9/82hJeWBR6cFXh5VVDHW+Raq4L3z7NFxPNBB5McbBwoYR+An9MJ47HgI+na1/3bALQFTqaofkh96aGC0nM0TfMzAH7m0r/92KX//zsA/s72Lu3JQCYaQ5dVbZLZANfABFpk7U7wkIxDWWRbPG/UHews1Y1964aTqpjkYIIxtCL164NNBwPcIlCRg3mwO18eyiLV32PV74MpQjw4K/D00YwvohgG27yqkST89TsmkPAMVfzk35oksRIKxuoCVU2FaeVgdPSwVujzmBEU6216Am0TaqSr6o3l3/fzoqLGENUYWo1mVtv3n9MycR4TnUF3mJ6v+kA4c/2Ell26hYXASBTYXlbPHrav8JdwSAvgutGStTw6VpZQBKLmK1qhtVl7L7LPZ/862LHAb1x+81e9mjpeDXMBNOl0Kha7Ad1iYce6uCcCnScQ2ZdmmqxQ8RwCHHPWxgTi5taWYuiE/cNubWU+gbCY4aoyAz8JCE2gm8bt4lqZQEfzDHWDYMGgJCe1gI2lYJLziBPDRpSDSbunws5aIuzY9aHsEM4NaRsAz8TyUHaZ1XQnhQl0cpbj7jrSnEGW2pK1Flkqed7ITCBhYQdA9sVS0sFmorm1IokEuokRywRSWSgekifQDsnBgDXTzlCMZr8j73mxIn2BOhkJX2xtGn7iyRpcelgL6mOjFGQAY88nVCaQMhb769DHsvW1hTwsWtmr1Pxeg5WtX4Yyb6nWG0rMWCangwkBFh5+LGAl7P5anjnmEnctmz6lUASyyMEUk30L02hCGG1EvLAxxnhUeiieQ759dU4H8P2pVW42Yb8wFYFGhvoiOTmYzRMoNHn2xRt18e7hd4KXgYQYJULcIndSjVndzgvd/Pp6uAWqRWKg7awZfRSEydVM9KPxUHbvAE1WVRokW/2/G8LJWYG7N7kJob8GxTMJcCwaJYVPloMJpphKemAfhTCxnYsygJqciHi0crCKK0BYfXuYiZVVajY2VDmYWog7WocVnBGS4H777PekJi2yBpePtb9jE1tWDgZY5hM1LfcD1gsXxd9u/apQ0unE1g+xUhir8fQ+oxK84fpgNw79MTrrlN0M0PyAAL2YqCZFWjZ9lGJrkujm9FXLPmXm1MlBFUKvC7lBDqakXRZr1qYyr7OMZSyD1rJ5PmH/MBWBRoZarXU7CuLuNTm5UivNl3HckwMMoRDkEpaIeJ0JZKOgU0wgw8RWSbWxegIpTKBZlko7FgDwttfdlo4H3Ofl5WAaE8inMTCfYymYOALGiPiyxhGZFgJovkxN0+DReYnbx5xs1BdyVLZa3SjR0tZ0MO56OmNojUmmFtSZmHKr1GxsqEygVg5Ge4dp6VQtG4s1MBeLNO2OpuyNtVsTW6Wvy4Q+FPAJi/x8YpZpUhiFTWaXNl/8+03wvz2kdYuSkNWHEsjhpOVaoZUtJNZ1IyWDXTiHKC3nGYO6HEwptmaJbk+gMIEs890JYVhsKCSPPjG5WfUc8mBZ0up8YsJ+YrdmsU8g1Gqt21HQbktbSAmcR11YX8bxwl1XqAjUycG4XQtAG7TUXX41mrxpnCkx5QmUcd99H+ykFrAvXJQI8UWWtFTXEPzn/Na3PitdD+DuF/s9KWyyfvvM96RQt5V2+1gWlZSeNs94X6bTvEJe1bhHSto6DwVNbgbwC3jfp7CTkkZYPAJdfDb7HVXGiPgZkVBllZqNDTliXSyiZGJfpHifATpTR5WzWb2xxka7uCA99LT5hJY2qm5aKQbvliRNoH+fh4+zpo/tMxRZcB9qOpgquWSf0VpgGXnIGw7qfDExmJcLxVY1JRXQPsPkCTQOivUGFM0EyrS+VC0CmdPBGq7PntLBDgOaA/EEGUo1+Dyv8NEvnOL5u8fSOVgafec+rxn6evhFbSgmvlvA8xRxRa6l0nvViG//NY5FcWcntf1rUPv6RqBZOzNc7gas1s+QagoNuM/C7t5ZzHfnpKRK9clQn5+6bvBPfudT9PEAf+0AcHKaAwDu3uKKQHODF4fq55IkybqvYyfm7ie7w7zI3PNGewIZ5WBMf72LEfGAu1cmg3ryY7QLR1XyJzJ1+GQhzTzekuR4Hfjnv/c5ANy7Nsv4vhpwRdm50Ida08HGDjkAwn2Fnw4cEgsiNh2M2ZQpBbZRW6AR2HyqJ5CaQNaxQseT2RR1g5sjRnsr6WCTJ9A4kI2hVSaQ6NdqTQf7F7/vxpvQJvdUTDwMTEygkcHICzze/bufBQD8f3/wBekcfoBm5WBWJtCRKAdjdjYtEfHqoO4NR1nUwuLIMrFVZBjWia03c2Qwn/G0Un/vFZaLx63FDOd5SR27EuMygfXOCxURr/luqalFn320pI/1UORgLy3dd/j0Da6Gn7U7p/riTllgKDucKoujM/4Wi0CqHIwo+CnU/OuE4rkFdAmCrLeXytosao2NxXrbebAGlx67ygRSuna3gOSPr+umZasy8J5ArFxFig8XCwQep+sxI5SamsBWZNpn1ALjtw/lXVDYOp1fDx8QoF7+TBzPTJuGqlyrquliqzqfAPR0MFVuNiGMNiKeNm7WvCRz0UfSjQW6l2dZNdR50mRKBzsETEWgkaFUa28f8Wa1fWTkro5qbHYZLRMoYAzamvoyTKDW+FhhKWg7wGmiFZn810jtzBoo7pIxtNHsUjEOnqe8MXRMEejurTnunxbUsZ5tFpr498HukvvYZBaeYcE+oxbD4FnKy8Hae0B6DqmJLf1jNSYW39dVYoFAZXEofdDF84T9ICpBvnOdcIw1/nhViqHuwBdiIVc1MFcj7lU523VhWVT4jne8ljp2Jk78lYAAoFsos1+RwgRKRSaZh2c+3gswH/3H3K27Oy4sxsqAVtBV5GDqWGMpYs1a6TH3HqieQBb5tyIHUxmbQPd9cj6SehDKhDByNR1MfI7yik9jde3bUn0fnBX4nj/yuuBxUzrYYWC3ZrFPIBSTuaePbOo8dlfHd2LWdDC/6AwygUT9MqBFxMv03kTzBPLHMnOrzsxU91thBnRrRHwteAUoEfHn6wKgYnrscffmAidnOVVMsRSb5imXbKPKwVqGAnkLVJNtwO0usZPapfjdqCwaQDcNdufhd77GNvVt2ToGqQHNBNoxOZi6M1g1jZTwp94D/y6yu5tdAUKVeZA7/EY50thYFjX9Lqtmo1WjvsN+Ec96xK2va6QkTQDtxsGdQKKjf5YPiQWhMH77UN6FSjCGNnkCGVJGlXOonkCq/BtwrEfWe0tlbALaZ5jkYONANYZWkxaLUvSqNDxHTdPg/llOWQlM6WCHgakINDIU6qc/6l1vvCedg5UkqZ3YZbDpYKWwU26RO6npYIm4M1KJC2CV3lsL12+NiNfSwXgmkFqA6OP28RxV3QSfH6ArNnkzcgZsEUKJPgf6DAXWlFiXC7FSNqB3D0ZkAqnvGOBkpmwBrBJ8w4B+IY6f+KcJ72nkwex+WVhS1wHXD/HH17W2AFOlr3qaivtJs8laFgp1uIm1eR04F0zkZcmfKLexmnMz98BfhyoHe2lZ4OYiCz5Hvv1DWbd0TDiDHEzYfJPmErJUi5ejtufIvKxQkwYr3mFyRLzgvaWkpLbtC59h8nIZB7kYrKN4JALAqqxkY2j1OTovKuRljbtEqMiUDnYYmIpAI8MvKpjdKT/x+uvf8ib5HADhCRQpB2s9gYJyMJ0JJKWDtabB/OJCaV/V/qby7qwyoK//xsAEouVgWdr6d4QQIwdTihH+PIoB9YwsQpQVT28Heotfcjz33+Xf/f530udIBbaaeg8yww686tkDeBr6OEwdNVmoqPSURYBLR+r8GXZr+EzFSVtV655P7u+4c7RGmuR4o5jV9o9TI+h3bZf8PK/ogq468VfivX37gGLsq7FaLQuLkpQjWUMU9hVqgmMfisl7JchGMzGEoGkaKiCjD19sYVkWan9tYViUlcAEElJSPbq0S25j9ZDYcNeFonKePWzRUpVrLYuaHgcA23N630trySLQxAR68rFbs9gnEMrOmnVnh6Xpq5rWy/AdVCgdzC+CmfOwfkZ9tCyFkei9uehlMUt5829AY1lYimTueC3e28dfhtDKwea2BTbALeSXhiLQnDTiU2OTuwQ4MZJWKBKkKb97190DjQkkRcQbmEDKpERtX30PqlrzffLI1vdhKIXMklx3HcgSbedRZYmonjodE4hnJAJ6AYLeDNhBT6CmcczII3qsSaWxRvZ9EoutqoG8Zfe6qrmCrr+CXSvyjQU1wbEP1ROIZwLp77CaDqYWo30/pIw1lnQwtp+zMIH868gzgQ7jHbhOOLmWxoxW7vN5UUnzXZVpBACfeehCS1g52A4NlRNGwlQEGhmZMLGthY7+wjnIHc5V6RaPZk8gWg7GL5LaApbQ2VjSwZTOTGVMqRXzWtjBs+5eK14BSuywpTjTPw/AFVNMRaAZp8EuKn7CBuhMoNIgB0sFHf/Se3uRhbiZuDvbP1bZZVYML3U2Hy9fAHj2wGU8OHP+Iz/0U+8faLtGYpCajQ33/fPHq/HS8uKrFBmVYpGmWwRTh+9kRPyqfZdH8gQS5TaZKLVR+wmXvqctXEryOe08gaTm9xaWBEcP5V2uBNlo1y6bDmaJiHfPKLup4T+jIuOxMIGUQpk+n+PNrZNp8T4K8qqmWa2Ang62LCocC5urioWAx0+/9zMAgNfdOQoemyZTOtghYCoCjQyFCdQZBtvOEeoQ/AKH0YNeBb8gXxbDHVsp7Lz4CfzY6WDKoJuLixd10qCY4mZGintd83IwZ0qsyXjU1CVA22W2+K4czbIgS82dv5ZYOqonUClM2NpzCLt3da0VUPxximG1/6hKoUMphqpsPvkeGOVgj85dH/mLH/j85rbrZueSwQB9caEmR6ViESWXjTQ12aIqWWwXqDvkCSTHDmdaEUWV28zFQp/KRpmJhUp3Do7V13kC7c79HROWQr2HwgRSkq861izPJFO70rm4qWHxBNIj4htpQ0NdvGueQIfDhrtOqF6S80wzhla84QAn85c9gdYs8re+9jbR/pQOdgjYvZnsEwbvx0ExgURDYg+WLeL1oAwV8CpkaYJFllLpYPMsoXYg1d1fYPx0sDbVRpGDiT4NABmruz5ETpMQUjdcioFmsmiV2gD87mP/bxgcLzLKdLoUqNv9a6DjyQ2FskSI9+58OLjj20K0sPoyFbIUJpD6DouMOJY9cBkMm0Bl0FwXVG8yNZ65e45YGYbfgdeMoceSFLZysB1aICn+eYAlHczoCUTeY/9VKr5MYzOBDmXd4j+nSQ4m9KfK4jdNE6SJlg5mlYON5QlkWfwWNS8VshhPVyK7foe6uCcGednQxXpgzQQS+jrFG861b/AEOsvxVa95ml6bTcXEJx9TEWhkSEwgw8IX4HdfHpwVyNIEt41R9IDzggkbQ/NMCwtF35IOZvEEoic+YvuKoaOfrKm7m8pCdT7jDew6FpbedcwzviBq2eU8mmdBlpo/v1KgUWUwqtTJnYO/x35gZif/iiTVeg5AK7aqbD4lzQZwfRCb1tIH87gVlc1vaGzMxAW2IvMA+tJdkgnU9qPs4kiLiFf7iDRNXHzyDlUJvH/eWPHSqtxGlY5aEtpMnkDChsmhLFy6TUP9b5X+tCA9mTxmAkNB8S70mIuSRdUTKDN4AinMU4sv1sQE+uKjqGopVEeVa50XFW7MVE8g7T4/OMtpJcjEBDoMTEWgkaHIGDo5mDoochM3TzdUIzn7OF6EJTeFkL7kL0UZs7yPAusXoyaS5JX7fAoTyBK/zcXq6kwpQEwHSxPkVU0VIWJMcbtdZuJdMJheHs/Dz2bTNOtFhW4MzbNctPhzQCsk1mI/MRfYiB6tZFFkEbCTHjkdbP1dsu9xVTe01KwP/xdDk+hKLCJeF27M0kFD68uwpoOx98AxCDhGqGvf/VSNoaXPYDBlHRP+fWELlrZ0MP56OuaytsDm2V6G+G1yQ2NX09/Ggp8vWsbiVGDdqQV1Nw6QnkB1QxXeL7cP6IxByUNSeMeapllLhPlit5wOtn4HmL40mRgco8CPZyyU1F3AjQVK++qmD+DUIPdIJUhqkEVO2D9MRaCRYUkHU5lA3qwstADIS62SfRWO52HJjUtfYqVI60mnUjHPK8zSRGDqaBTxvPQyBn6BqgzqijG02RNI2GH7/9l783hZ0rJM8ImIXM5yt3Nv7QtUURRggQUUBbK4jAqKSzcu1bTSOuKMPaP9a50Zu3+K3TOO3TqKS/ubbsVxaeVnu7RNIzo6oKCCDbJXUWBRBQXUvlfde8/dzpaxzR+RX0ScPBnxvc/7ZcTNkyeef07VuXkiMjMivuV9n8V0sJpkqwHF9ykzSecXuMv9wMpSKyQqbTCBiCIQsTkyb4M362yObWdey7A4fI9gM5FeE1rfHklROtuUzt/UKRmby2D9OFjWJuuhEJCeQEmabSCZpsa8LWwLORiRDkbONap0MGmhT+Gfx/qhxEK/FWattQgoxmh+LCrWFbLGD/McM00x9v4ENE0ZTnKpbeqJmUAe15ABOHkzu97tIMMo4uazHjnWxaw8O+A9gdY3Qxxb6YteG3jcvqbD/sT8rWQXDIzGPt/ckZPiIE9LqD8HW8mehiXBRpuhxuaeN8TCnI1SZBf+xtBUmqLGdpeZDbY3fgtNpoP1hfcP4OoJJC/4sWaOQCZV3BxFluNy8ovye2jKqwTg4jjN8aV737Yi4llPIIaNlXeuxZ5A8rSWMszbT1F9nmhO5WCSsbmMhPANAxTpYOTmUbO5Y6/DvC1sTaeY8RNh5xqmSMZGxO8YJlBDSZoAwQQiC8X7HcUcyf8t8yyPYnlTDzDm5UwzgHyG1Uwgua8Rs95ii0wBWcgF5ObogPEEOhjPQJsYkU2NHhG4AmQkAGY+1niRntkkmEBdMfFAoCsCNQxGY69NBys28S0wgQTmuxujGKtCgzPP8+goQroIRE6KGztZIWFlIPNOYhe2jNSJ7cwCnPE0UGxAJNRVFyZQ8Vns59GYpA/7QV7Aq0KoYOnQTKDEsI2YDbC80GfuZXFnkDTrBMrJS+I/gU8UQ+l4ctO5Fh6f7doZmOPXnUZrOt00pJ5YBuwGjC3SjEgPBfY5SxQbSI0nTZMwxRYmXppLB+PWE6wnUNNJmtl7kRUheqRkdL+jYI7z45wxoN0UFI2jhGf0MZ5A2iKQOCSgYU+gXBIpTutUeA5RTKAuIr4JhHFCGUP3A48yhmbXFSyrchQnSFKIzaf9zhPoQKArAjWMNtLBgvEmz1YE2iEr2dMg8V1Z3xhRCWRsEWV7FGN5wHWYmcHMpKidEH6Gnu9TscOUHIzw0TFgjKeBktEixQTi7yOqIGo8aYhJcRDYPVEi0sOi/B7ELBRy0QlwnkDmu6EMX8k40VgxFjER5RHhG5Ydm/M12gpjrBBJGwbm/dvSwVwZlU1geWBPbiyDTQejmUARt2jWdPjZYhzr99E0ihS+ZuRUrNyGWa8AxZpDzJpVFOGkmyNWMrrf4cIEMuaw65sj+3nosdoTr4c0EfGFzyYpByN8t6i0WjLhj01xBOTm6EDGEO48gWaPME45Y2hfHriisQJhi4lskAKbqtxhf6IrAjWMNtLBgGxTa2VBkIvyaVgWdJtPb4xwXOhAD4w7FyQTaJmUgzFz7vq4CHRM+BnYSZ0pcJjuEkMrZU2VzeJFIhfKU50Um2Am2tWch3kUBj0fSVr/rGni2/VMIM6rRDrfJgrGYJZUIS8kPrq+mf0dJdliClkJdQ+ZtyEdJ9i41fx9GTlYzcWI4vlkAkk8scpg08F4ORgnP2aLrbHGT2ROPYGk3xMjtQH4iPhCDiYbK9gkzZ6iCCfdAGu8z/YzXJI6TRHINLzqMIoTsdwvez+kJxDZ9PRJVmhMzvlsEUiT8KczR5en1R6QR6BV8MbQnliCzzZuAYU0mGSQd+lgBwNdEahhtJEOBmQsiDCqf2BZev40DPu+lQl0fifEYSKGnq1ob5NRimbMky4azm2HWBkEVDoYM6kz6U5GysPQShNysC8KTbJ4dUDnCWQ2ClJppDQNY/L4dWwglroN6NPBmMU5I9fSGOKyC4Z7nzwPALh6bVl+Ds+D9DYdCc1e82OTBYKtMKEkowZvesWzAAC3PHut8jVRkqiYcE1jqR9gO4rF0tc44dL3zHi4I0wgoz2B8k28cOGsYAJlC1vqTxoF61HG+omwchtNoQ+QJ2kyklEDKROoRxqL73eY+1gzFy8PAgwCH+e36z30gLExNMNQCOSSRdazCuANwFn2MlsoViX8kYNQTLCxfK++idFBB9oYOuDk8QA3H2fSZmJfQLK7WW+sDvsT87eSXTC0kQ4GZMaMIk8gRyaQRFYSE8bQAM+kiRIuoplJwgB0TKOmjKGBcQoAJQHIfkq7Cnm0rmA+iUkPizJyJpDIe4jrigDFRqSuCMRSt4GC9dRkOhiTrKXpnrJJFVGSYmUQ4PpLVuXnIDTwO6Rci92cbpPPsMGrbjiBSw4NcenhYeVr5jUivh/4SC1MuDIyrw/55zi2nKWKSCQkQFYsYtNUAIiLNCyTCTDS4PmpAoXkBpL1NGIj4pkER0DBBCKTNAHDBLIfn4k9XwREOVtWNxZJ2aFRnNBBCtL7J035tYRZr4jlYKwnkC9vZmTHN2sKeZGJvUV5T6CD8Qy0CZYRZ5IcJQU5tnGbvZazoWD3HayNRof9ia4I1DAY/XK+eVexLOzUw3AGTKCe4DxsaguzAQbGtExSpgIQLIIRxyJgKe6F34rs9X3fU8nB2PQoyfeT+xAoFp75eURJebxXQF4Eqrk/N8bpYdSilmQCsfRzIGP1yOPV+YU/Gye6NeLM14Gxr5HwFJm5e3PXIHv/urHO5mmhSaVqA5L73+Dcdoinz+1wXh+Bj6PL/Vwua0NILpr9/BrLdmCspxEwh0wgxQayyYj4gGTTGFaYdF3BmAYDWRHrnsfPcUygA7IBThyYQObvJNciTPiIeC4dTHxoAApjaNYTyOMYFrqEP5IJJDRHB7K1xDyNcYsCjTF09neEFQgj3SWYRkBJacIUQw/GUHqg0RWBGgZDUTYPqaaxI/EEGpEMnannEZidaZJ/WCM+ZoNtNhfSteF2yPmJsJO6WfhIadDZBp6nfTLpUdn7kqWD+R5HWzUozH0l3UdOLgQAg/E9Ufcc/It3fIY6JsDTz0MFoy8gdPypokDGpgqxbDjAdFCbYduxZqDbEV/EKp+r7jzz6gk0EMghDV7zc+/HPU+co+eDYyt9nNkKRa/NFs3cohaQM4FYw1qAbzg0jTDhWAqsBEAdES+Wg2WvE6eDEbJXAPjYA6ewFcaivzFj4sExhuYDCMroB3b2OKDx9mLSwXQJfwDHGGTWLMZDUiqpMt8hIzdjyYgcE+jgJOS1iTBKqSKQmVtlabjZTzaogYuIH/+d8HnzuvvoQKArAjWMIt2JkIMpPYHsxZmE0nZPg0TywXbKWe1pmJBys/FbEbMI2A0qWcRiDU0zlleDBnCefFEVCan509AjpAbZ4pA7vulGhzWb4M+PvW42d+xeCAY+WQSKFb5DjCcQG+0N8KlCLFMnPwfF1JE/Y57nZZGrUqNFh0KNzdMiSjh5RFvoE0yg8+P7n005G/bsCXwGIZlGae5paZGDNT0GdOlUTcLM+U0lF6UpbzYK8MbQcv88ztPIeNb8s6+9QXRsoBh/Fx0uQSKAkYMJ2L9kQ4ZhAmmKQCxjkF2zmGdRepuaoBRpYi3LNAK4dLBeMF+F7kVBxmzlC+oiJlBuDC1/P7QnEBkoEnjzFaLQoRnM30p2wcDFYjt4Agm6OlHM0+enn0fCBGouwj2KuWIWSx/eGnFFIDaxJSE38VnUZHMGcGafJrtHE/2ikyimaExfB0F2zd+G71cAACAASURBVESbYIEhpgEjlwNKkjkyHUzuCcQXinu+lzOUJNhWpGsFRMrfFsm2A8ZsR2EBIlb4JhkEXv13xSzI28SQYAIZsAVdKXsAyJinGmNo8XOgGCPmrUtO+8Ox/nMka5BnAmXzgZx1yjGBzK1wbNme1FmYx4sPv68RkwXESfR8X+TPp0n5kzOB+PVu4Q8nez3NTM+fAdkJTCKjtKlhZDaMeTOTDsaax3eQYUQ2NcxrJWt3zd7P3EdsSh4jB+vuo8VHVwRqGMyEkpCazTL6PbtXzyw2L5nBrI0JJNcvA7xPAysHM3R4adF8K4wxJFgQPssEIhclWu2v3AhRLllkaMmTMBtOaWeEjb41C9W6TbBhtywRBQjaiFKxOPeJAopJB2Px5595XPzarTDGEpHAB2RFL8k4tx3G+PtHz9Jj0aBnl7waaPxiynj33z9R+W/hnMrBzHv6rQ/eL/4btiOdyY6FBQKlMbSUsRan/AaYZaI0DSYpEuDNQFmmhWG4Sb+jEVkg6Pk+1V1O8zWR/bVsutx+hyZRqIy+kAnEMvoka0SDTK4oPjSAErObkGuxHpWAfL24HWVFIGnjkA05MK+VexodHElkm2CDdTg/WP5ZztN2iUARgAuM6Rhli4+uCNQwWPYDoJODSRbnrAxpGnqBb2UUaDovzMItJOUYZo0qHdBGUYIhlQLA0SZZlgLTfQcKGrOY9mmYQJIUA5ciUCBfpGdyHu74Rg5T911918uzCPDvfvm14uPm9HDWGJqMQJeu21izVwA4vjrAKlH4GkW8ifxQWKQ5O/aUuWZthTr+gHgOEoV5tsFlR4a1nz0mjVLbwlaYbUZ+96MPif+GYQ0B42tAyMEGBH0+TykUG6Qn9AaYTXJsGuZ2lidFatLBmvME0myMqPefz2X2z8B6xex3mPlazQQSeA0mSYokJdM0iWucKuYyz/OoNSOb5hiQstTtMRNIymwtGGssE4goFM/RGLcoYIuhhTE0wQRSSHfZwJIuHaxDGfO3kl0wtJYO5tsX5xqJzZ7zCHw5NOlgDIU7ilNKDsamg0VJQm/gqQj3JKWkQmy8NysHKzT2MoaOSxoJQDCByE18Pzeerj5+mqY4ttInPaV4iQTALc49T35/ajyBbnnWGvV61ncLyDqhWyOZvAAAbrryCHX8fuDnaUQ2ZAVv6vA5XnHdcYRxUknXd2HDNYkNwufKgPEaA2SM0+LYcxgR78uLTG2gYG3KXs+ng/ESA0DOphmRiaNsw4fxsThoTCAzH2mZQD3f7jVYJF8xhrhEOpjCEwgwG1TZaxkpFcAzgUzxXcqc1TGB5GymgJRcdrAjHhdDufnMyMHkBADmWWYL9izbyBikd1hsdEWghsGkg5mHVJUOJpSDuW5ebDrUJEkzM0pKCsP5NERxQk3qZpEhjhQl5WbswpwtcLDpYLzPRPZdSr6fONHLbJjFT6I4T0/QedHEexeLQqZIQyY9eJ7YIyBJ+YU/24GPSAo9kHkibI8XxHXQep8Ne3Y/svI5tJ5AS4MAaYrKgpPmu2kDxqCUgUYOJi8CcWkqrOFrnCj8RLz5YgKxBXvGDHQUJXj49Ca1nmAK9eYcLBOIYeoUayL7hwjIYv1+h5EFaseifmD3GjT3ASv5E29MlYxNJuUvJlMEaU+gkGMCsZv3NE3x4S+dIrxcOMnlIuL2B0/jB373kzh5YWcmxzNzHlPwZoNQgGZN/HPWqbg5PH5vB2Q8PajoikANw6yPJAOBqxysDU8gUwmvMhTU+KGwRZQwSalFSV4EEi4+w4TrYAesHCzhNvHDnpwBAfCeQHm0rrBjod1cF5GZ9vNsjCKskMbBEk8RTby3JjaZNdxlfKWShE9OY6OxNfHby/0AW2FsLWblYwSZTDXo+RhF9iJTvrFWjnXG26GqoDWLYnoTePNrrgMA/IMXXyX+G4ZhCHCeQKM4ySWaEjDS6ex1vEl9L/DniilCU/QtTZgyHj+zBQAYEt5eLEshZJlAHscEMkOJpFDg+96BijVm5/lJSKSFUc5qZdPBCO82xdtn2NchOU6wz8DOuPguLYZqmkoAAOFtzaSzLSp+7W/vw19/7ml8+uEzMzmekbkz+47cGFpif6BojLHr0uIcsuPnqcEHvKC46OiKQA2jMN1tZiAwkCzOZyFjsG20i89AGitTRRSWqZP9ZJhAvKcRKQcjCinLQoZF+fgAYTZKMKU03XeD4t6xPwvrGyGOr9oTYXYdXzDpaiLuNV4lbIGDod4mCqkczQQiC6FA1gmNk9TKIojyDrYmmaqZrloZpgi0VfHMRXPqCXR0uY+rjy1TzAzGawzINjpMfDjFBGIXtQpG3IBImGsDccqN1UxSofkeX3XDCfH7YQr1QHaNqYYJm6SpiDU+MEwgh/UiMLYQaIAJxBRoNP52wJg9TsinOSYTbx8AyJsajEVE+X18zfMvFR+fSZNdRJjEtvXN0UyOZ+YMigkkaEoaaIyhmUCX8jkkrMryeznoBcVFR+9iv4FFBzsQeJ78IS1DYprqYuprkC8SKz5PPiEyFe1AnowEmLQH+WDsedxgFsbcokElByO+n+VBgGfOy/0+2A5hYdgsu0fJvfue80gWP6c3R3je5Ye44wukDJoCDZtadMdD69Txgd3UW9tCIE5TeowIfA9pKpfZRWShFSgicrfCuHaxxC6aDTImkKCY7pCyCBS0frOQnEQU8wyUtpCxBuUFY3aB1w9YTyB+80VFxJOXYdDzsbkl/36aBruRLy/MbWFEmgjxgo1FFPrYEIWGjKEBnpW7n+EcER941vE0atoTSOFvl51Dbn7MNj99cr4vCmXNMoHknkCdl4vBn33mcTyynjEil/sB3vzq68SyvTLCmH8OctWEyBg6+0nZRCg9gaTnCMj5uMP+RFcEahgMtdRFaiNZnEcOxy+fB6iWg2m6U2z3TkNBL783G1hjaHphm3CFFCOzkSI3mRNeAsoY2kUORhjlnd0KcXS5Tx2/bylQAjo2nE/SYp8+v4PNigJCFcoT+sDy/ljPrfLx4zSFD0ERSCFpM4l6O2EM1Fy7SOll0Q88UfqYGZq06WBGPlPHBJpHTyBAXigz+L5XX0cdX8rGAnhjaLZDzo7TwJgxO09MIHKDxyz8zQZeI4URM4HYa0zO9axPYs/3cq+cRUcxz+vl2RuWeSqM0vy1UjDpVKmCzQcYU2uhFwo5l7HFaHY+Y72rInJNHRC+YYsK0wj50BdP4kNfPJn//sbLDuG1N11OH888B7oikGxdDcilWtlrx2s6wiex/Hc2sEWmDvsTXRGoYTDU0iTVT+h9QXRvxgRykzHYNvIavw+f8CtJkhTbYZJLNiTImS4NGkNTRawkzZOsJFjqB5WshGlgfBQAslCZ6o2hzZ9JuszbozhnlkhRMI1q5GAKrxtzXGnn7sJOhP/+Vc+mzlHuGtkKnMZ4mgHDIDDvg2FxAPLoW3ZRa+AL/UTYxKVJmFjzqsUbK0dtExL/sHTMOP3hr7sR3/+a66nj93u+qBCXpumYUalJ5ZHOBaBZiZm5+PxskOjEFkq6q2cCSVkQLBMo8DnWr/EXEyddknPxfkbhv6gb6PoC2VCRDsbdQ4zUSbOcWB7IJfKR0hOIKUaX/056fDFbKuaLQAe8BoQzmyG+9eYr8atvugUA8Oj6Jr7y5z+A0xs6eZiZ81TG0JLGFTnO7To+4b8FyOeafE06R02TDrPH/BkbLBioRCQHqU22OLdvvlw3L7YEJi0TSGzCNx6QGEonw0ABdB1sNt2MuQ5LfZ/yBKIlBgTThfUzKsPzPPQFZpRAxsJgCn1AKSLeygTiHjKmcxcnKc5uhVhb4fyMzOJCwlJIFIU41nRXM1ZIGXfm31lfHSnN3bVDPgiy+67qWmh8pdqChAm0EyVI02xcoY8vTAczBTQNY5PZQLKFRJYp1TTYMAhzT6eCj6AptrIb4DBOcgag9PgcEyj7yXgmHRT5gllzBMo1XS+we/do/NsYebzG3w7I4til7OiI9ARii9HGPkAq0aaLQCnPFjzoTKDTm6NdazDz3+///NMq4/g8HUxhDC1pmqj2Tex9RErO8jXpHDVNOswe87mSXSAwBQgXqY1kca7VX5fRt/i6mAU2w3TxiUVDHsepYAJJJ0Y2RY2Xs3GbyCVSDlZ4rsjOwXgCuSYjSTYBYZwgSlK6CCS5znGiZ7hINhfnt0OkKdRSNskGO0tU0UnamM0dW+iQLkpMZ4y9jzxhsThRLKjK6FsK3fPtCRRYF23bijHUoB94os5g4aHAMUKZdKdYUdDtC3xQ2kResBQX7LOfHBOI889j0p1YORjD+gUUxtAHkAnkktZZJes30DzHTBEiSXQemEuDAFuhfD3HNiUBgglEzpVSxqwBG7bie1mzxJbSuajIG3GlYJGVQQDPA/7y7ifxsQdO0cfM9zXEWDcQ2BMYaHwM870l6S0lvVULJtDBvI8OCroiUMMIyA22Vmoj8QSKU3cvi6KoNf1cZ7dCAMCxFfkmOPDkC0NVEYiguKdpOmZBNKOBB0zyEkf7ZI5/ZnN8DYSFCMYzybUI1Pd963XIrzEbEZ9v3mfrCRQQ909uEkl0x4Gi62KT8gB86hKgYAKR5ugAUQTKmUAs00i2sNVQq8uwsbJmwahsCgOBMbRmDDXoCT2BNEaaAFdQz5om1OExmFM5GG0MLUkHI2UkBkwhhR2LtMbQDMuii4iXIZOD2RsyAPccs0wglRys72NbKJFn/e1YhgU7H2iOD/C+YQc11ensVtaIO17ag3ieh9/7H74CAPD4mW36mJrnwKaaKMPNxF/+rAEaJtD8BCl0mD26IlDDYMy1tHGZgDHsrB5s0jR1KjIV56nfaBvN7RoR790TSoSAIrFniSgQMBT3fIPKDMZkkSbzHOJkEszx82sglCQxEegaCUYZQWDvEprFHesJ1LcUKLN/4wuhDBNIG09uJBWSBcMoTukiUxBwcaJRklD3KCC/jwoPBfL4niz5xzUdzEbjZpmCbWIokDuZMVSTktIPMk8gWzFupC0C+fJ0J01BehAEc8YEyn6ycjCKCaRIQ5SajYbkWOSTrNmUZAL1fP/AMIHimE9iLSPwfatficbjkfEE0q55mbAMrSeQPE2WY8Oxm3fzLIrZggfc0LdqD3LztUcBAOsKXyDNfKaSgxHrxsCiypgE6wlkivujjgm00OiKQA2jmFBkA4E+HSzr0FYtzs04MTMmUMXnWd/kChDAmL4qHMiMlGGJWHj2iQ1wroFnKO5kkSaT2nCLKib29h23PwIAWFuVMYGYRYmrpFCyQPzYA6cBcH4igCyCPlb4uTBFRE3KA8AtGEZRjKGCYVF+f3XITX3VvkP1r9Omg/lCw8uE3FhPwhTk/uffuwMAcMdD67juLe/Ggyc3cqagq8F+UxgIjKHN5smkoFHHFy48c08gTRFIWIDQbCD7PQ87c8gEkt5OuSeQ4CvSpIOZ1zfJBGKYOua1cmPog8OAMNfIiT0ukGZnr+WY0VL/xVgrB6OKQEqmDhMkQlwDJo0VKMn7SSbQQfHGmsSZij3I4WGWg/T7H3+IPqbG446RgyWKZ7lQOMjms4gcS01ARucJtNiYz5XsAoHRFyepbkIEisGp6jzaBeEkbJIbU4U/TjCBmO5vXpEnzSgB2WCpTcNgijSZUSHno5Cmcq+MfuAj8D0cXpIVgRi/GBe2GpAVEW2bPDOJv/y649SxJZGcGcOlGZlT+TVsoWxA6K/DOOULZMTC1jxjQ5KJVdxHdm8ygGco+J6crQa4pIPt/sN3fepRAMCHvnSyMLXex0wg8++Moa+B1Lsq91DosZI/+ViqkXb2fX+u5EK8MfTuv5Mcm09D9MWeLiNBmmEZzRtDc9Ls/QwzFmobe5kxtM0TiJfu9gRsX4M0TVXjdD+ws5gMaI9HlgmUkEwgwiIC4CWjrLn7omFjzHRdHe4Ov/Y8D5cdHqrmPeODRxW8GTmYQtrJXufz2xEA4OiyLBTcBGTMk3y6w+zRFYEahu978D1hOliimxABu5mpxn1++nnqJTfrGyN4HmeMmzFpZK/VLGxtZtZlaFgKxthaasTHpoPlLA5poSxK8MrnyAsoTBqGC1vNnMtmRmk2kCcOcQlbks6IRkLCeiYBfIGjT+ivRxFvbp17iQi6UtujcQIfWQQq7qP614XKzWkgNJVl2QOTmFzQl8+Ym7HOtSfQ7CUeBlKzSLUnECGtTRSsxHmLEKeTHIkuvyYdDOB8ezImELdx0RhDe2Km1MFjAmnXdBLpXJRLzprxfYoVIQfmHHLjZo65SXv2xBzTiA1pYD2BAmKuX0Tkcucp65dX33AC20JD8TKK5jOz75BL/DXNQ/NMSu9TI4M7JlRpmDXmPMmnO8weXRGoBUh16rEyLhOwL861XcFJ2CbI9c0Qx5b7ZEWbS4Qpvw/Z8eslbGXki54GNd5sOhhjLv7pR87g9ofWc3NoCRiWSJLIpQvT0Bds8syEq5GSAKiluIcOnkCiIpDSlNh8VrExtJIJJHkGtMbc5nLZ7qM44TcWAJEO5miYWv5uy+PSL7/vXnpB3jaGPbvnjVmUar6fvjA2dqTonAKc/5nGn8zMr/PCBkrSFJ4nZwAzcjBNOlj2erthsAE7FrFMIPM5OybQXphNvnacG8UJzm9HtR4pYS6P55jRYp8SpbycMZ+OEk5+zzR9NMdnN++swTuznltEbNesX5YHXNKugaapMRAw0w00axaWCWRUGtLAGDOuf2Jsz9BhMdEVgVqAdMJKHIybJWamgL47XpynfqO9sRNhZSCjGxr0fJ+Oy2Q7U4Aw3cnIPZrUkDe4KPmPH7ofAHD34+fEx/fJIodzRLzlOmjiOIEi3tjGBNIUHxg2H8AvzHO2mjB5SWO4C8gYBGaRtNRnz2EWtzKJAfsd+Z5HbX61Y92hEo28PJ6ub4aljdd8Tp0DgRwsyiUe/GcYCCnuoUK2C3BMkazDzxZ0s5/zskFimZWMHEzLFGHYWKyBfEBKm7uI+GrkEhLlOPeOT2begb/+wfsqXxMqGjKB74uvcZLqxmkmjGMUJdQ4JPEWLCOMWXl/9lNc7FayBQ9KMXQSdemXS/1AnCpXxoWdTEq1SuxtuHSw7CfzLBfNZxlT58zmCEeX++Lx+sbLDwMAzm3LG8od9h/mcyW7YJB21lw22AML9dBFAlCGLSI+TPhoaZ/q6vALW0aDraE/N00fZopMmmmflTu5GUPb/SbCOEvz0DwLtqS5KElUUh5poVK7MGeu8Y6CCcR0jero1LXnyO+j+tdpJXOBJ2SrOaaDlVPpJsfT7XH8OjvGtYXBOL2rbgPmwgqVUtxdjKGlLJQoSfJEQPnxuS5804hTrvHDFHNj0lDWoOf7VsNggyjhDORZaTPrCZQ13A6GfCFOMhaZdpwzc0HdM5qbEiu8UOQeg+JD52CYQFthjBViLjNjhLRQGcYJ5TPDMoFYvxgmkXgRUbd+YVLlyiikVHKbC5UcjHgWCq9TIRNoM6S8Wg8Ne7jk0KCTgy04uiJQC8g6aw2ng/Xqq85ahsIkbMbQsSJaOiB0/JqFrXmtZGGrpT9n701QpElT3H9yg0zbkGu82U0XQDKBSJPFSUg6eGziTBl935/6DPz9o2fw2cfOZkkhivcvTZ0pJnNlEUjIBGLNDZlCZcEEIo2hhR1OTaEVGKcIija/2U8X7yqDUZTgzofP5P9vzBVdx9GmMOzb5Vpav57y39gWtvc/c0F1DjYinjd5L/52HpCQc76RjUnePisjMZAWUpIkRZpyrDiWpZB7AhFMoINiheI6FxvUzbWhwiORDVLQeQLJLBa2wxhPnduhWK1MmAvAM3NZ5jjLfmeLWIuGfP0y2Pt9LfcDRElKmx2f3gixOgioNVHfslcqQyMHYw3G1zdGWCOKWMC4qdQVgRYaXRGoBUg10mkqX+zsPYeMCeS6MRpaPCE0nisUE0ixsO0JZSpA0flSTeqCz/DYmS0AwE4k70YwGm8NQ4GNiHdLB/Osk6Im/So/fjCdSfAPf/XD+NZf+TuVhASQe5Vo48mZheFIIQdjrvF2DZ26/hzjxaflM2h9daQR8QV9njr8VIRxis89UUgrDS18Xj2BJN5SszCGHlmMoc13dvXaMnV8psOvmmtIJkrTiBNuLjMvlRVDdddZylzW3Eesf16ay8E6JtAkXFm5//IbngcAWBlWS1zMfcDMx4z/XJrqmEzSceLn//LzAIBPlQr5kmMDhMdjxMnBiuMLo73JNa95KweVCbQdxvC96cVNc69vjOdxKc5vh+K0XQNjT8AwgTg5WH0i9CTObYc4QgT2AJmcu0sHW2x0RaAWIJ2wXDbYtgSsWaWDmUr4dgWlMtL4lQg7/IBuYZsbBksWtg6dL8lgbKrq33DTFeLjM91TloUFcAWIRJnmYdAL7MadOxF/D5WPX7f4jJOUlpAA8mfYnFvTfTfvzwYNU8on7tGcTq00hrado+mI+ITcOE7Dv/tHLwawNxnjwrYpAs3n1Dkcj8913btQycQCgIGFcWpwfjvC1ceWcfWx5opAWcqishg6J3SRbDyVvz43tm4yHUzot6ILaWheDiaVR+x3aFmtBt//muuz4whYg40xgcj73yBrrNo3p4+uZ003ZiPLFoFGMek5lB9f9nr2OZs3yWvb2BrFWO4HU832DRNmnQhOAXSsUyBrmkjuPY2EnS2ob41irJBrOiMv77C4mM+V7IKBSQfTblzyBKxKmdZsikDLtiKQiqLPewJRcjCCNqmRSjAR6yraJzHYM/4MBuaeE0fEO9xDgaAzMop4uZNB38I0ipJU5QkkNndX+tEwOv6QXHSWjy+5xnXGinWQ3keFxEAhFSI2py7+Z1UpWBd2QudjN4mhJSAAKBtD65lAtmf4nifOUf4DBkw6mGYTzBYhmgY7nuZyMIIRxz9nsvVKqJBmM3MlwBtD93wugn4/45HTm+JUuWkwDb06j5S8CKRISxV7AjWYDmbWqU15MALZdzQgjp+zEaVMILKxxKabLQrSNMXdj5/Fxx44Vbn+WhvPSadrEvGmQVtw7Qd25jugYwKx6WBbYUxL/PudHGzhwcU4dVBBzCJQsGgMbBOvtis4CcMO2Kpw2A9jjVknzwRifAgY2qSG4s5oyDXXwVdM6l/zvEvFr2U6U6yR6ST6gYed0G4MrTXe7QX+ns5m+Xtjk9kMpBsjc2p+cyrT8SdJmsnlFGw7QHaPbis9gaQd1FjJlvI8T+aFYnyZHDZIpgg5Wew+t088gXZqNnYas1cDWwolkBVxP//keXz51Ufp47MNAZpNRhYhmgYbBsHIwdRMICHLQhNRzm5czMukxY7A97AVzse1bRKnN0Z43z1POR0j8D0MAr+2CGSuE5eWKmOipGk6tkDQSdgl95BhPnzlc+XrIVauxXoCFU1J2evNsy5dUxTP2MHavN/5yBl8x699pPY1x1eyItA6WQTKmEC6+ZKSgyma23VMvjK2w5hu7A16PkYHhFl5UNExgVqAdMI6sxVS7vO7zmEZEIqJxO2SL/Xqu0ds8hXAxbqqmEC+fLDUSCVYI0SA26Ayxzffz29878vEx/eJRQ9rZDqJQJA8M1KkXxn0Am/P8cudjFjrCeTLmVIAX4CQFmlM912bDib5DLknEC0HE34GheQSkMtGNWy7SRwba+fPboU4UWK0zLscbCAo0pjvX8MaLJhA1dfB+J0xhWgDaREoTdOxMW5zxdA2kJC+Lm2kg0klVUXDpBnWLJBdZ0ou53tzU+BrEpqEo2noBV6tNDKMeGa0lAmk9YYDII6hN2xE438kASvXoiPiPa5Iw3oCFaxf8VtaCJwVSLzM/XB6k2UC6ZqHTcrBaCbQSFEECnyMCP/SDvsP87mSXTBIzQrXN0Y4tsJT6M05gBomUD6RqA6fw/c9DHvV3aNQUTH3CQmAhkXARcTznS/m+ImCKcIM9nGS4vIjQxWLQxqB7moMbXsWwlhfBOr7e5lA5Q1xlHALNgNpRLy2AGEkarZFrSlosUwgJrZXKweTblAzQ1NeMif1BNJQqydxvEQb930PL7jiMID5N4YumEB1cjA9E8jcd2Gd8fR4DL3kED+X9YTjkHYDyfp9NA1WDpZLLgVvP1QwdYBs7qNkl8xcRhbhWA+6wJM3lPYz0hlJ3mzzfqi5xsKmWz5Oa8IshPNZFKe46ugSNdYxTTEgm5M1RbKmfDAPKhOoLgzBwMjBNEwgzbq335MV1DWJpj3C+ylNU2yFMd3YG/Q6OdiioysCtQBpZ+30xgjHlUwgMwlVDQjF5tT9ki8PgqlysL/53FP4zCNncH6bM11junc//sd3AWCZQPbutYFGKuFTcjC+iMV0fyNFdxwwXhz21yWJm8xGkjyjSb/Kjz8lHWwXE0g5mbMR8ezbl3ZP8yIQWSRjJIVbo+wcbCGR6QBrChDSFMFZ+J+ZItBb/vjv8cz5HZwZdxnN2KbZuLSB4ZipKUkH0y5qgXpPoNBBbsZeY/YczFjaBnhPoOLvJMcGdNLUpucyeUQ8z5ptu8B316Nncd1b3o37nrnQyvm+/+2fwLe97cMzOVbP8n1FccaAYCRb0gKN9v4ECOmxQr7OM4GS3DBfgqJIxrHfpQWCeRvj2sIP/v4d1tesDgL0A482hlZ7AvkyY+U4ZwLJj00F0sQJkpRf0/UDrzOGXnB0nkAtQJK2EcUJzm1HeaWaRZGAZYmIn0HZ78hSH2e39g6iv/PhBwAAX3jyPHU8KQtl8m+kKJg69sHs3FbW6T+8JH80pNHY5ddoUgBkHQWt3EnGVtPSYg16gb1Tu6NIvzLoT0kzKD8TofL993x7qhlQmszJQpnULNIUMtkiENM1CuMEvscXCUyEqq0IbDYWLHzPg2SYmEUR6MShIfqBh41xsfvJc9sACiaQJmGuDZhx69yU8dmA9ZgoQ+IJ5GI8bduUGmhSiwCeQt80WGalea2ECeLiCcSwZptKjgKye5UZSqXJQIwL1wAAIABJREFUZrPEu+58FEDWBLvh0kONn+8D9z6T//cPf91znY5lK/ixfjfZMWXXuLg/NczcMtulemObKNZDrHEz+x2xRRqWXcysFxcRr7vp8srnwvM8rAx62BpxEfFqJpBUDqZgLxfFSvvx9QxyX1wM7bA/MZ8r2QWDpLN2Zrxo1ySqAPYEqUJG5X7J11YHU931zUaTnXp8z6P1y9TCmWDqmM91nJDl5dHYBO2TWTgXEgApE0hbBLK/Lk54GU8ZkmKKixxsGn21/P9pqisO+J6w+66UYEgT4EYKjwag6DBJzcs1bDLjZ2ajWrvdo0QhzlGy9XUvuGzP787PuTH02ord88B8hRpGX1/AqiyKAwomkFDOk5+DNYYmkhDbQEx6rDFysDhJEJAsDkCW4Ajoikxs8lJKMoEYafms4MHb9bNNvPCqI05/3/MtnkAKj8c8iMOyHmqDCRQpPAzZ6O0R2bRiC9HseOqT73/R8G/f8ELcfM2xyn8f9nyRdKyMKNatieRyMP1Y2uR8mSkEuirQIqMrArUASWfNbJzWlJ5ANsmTNrVoGlYHAT70xZN48uz2rt+rE518WRqJFr7vwfdkRZozmyP4HnBkWS7LCwgmkPmczMKW8RwyC38WUr+VJE2d2GQ9wQaDXVSVMZjSeZn8f7UnUJNMIKkcLM6YKVomkNRQVnMPDXsBDg17OGUtAiUqqZAnvUcdNhdlTCvIf/S+U9mx51QOdlwQgWu+Q42q08jB6nwCCjmYbnMnKdBoTImB0gZvTqQSCSlXYeRgLrHGjNxMw4IQM4ESkgmkYBXPChdDfuPa1LOFckQJzwSSFlE0csLJc9jmy0ThYSidiw3COEWfmI9Zc3TWO2nexrg2UGZG2taOwz5fBNIygXpCOZiLQqCuiGuQz8kK5uxBLSYeFHRFoBYQCIocRmawOuQ0mwa2QoGm+FCF2x9cBwD83F98btfvzWKB9ivxs+hnxuzwKFGkAcbR4YLB7MJO5qBPyc2IRYO5DTRmoNKKv2qyCoRFDkVnrQzJpOLMBJqYdCcnfJ0nkIyhkCg6OoDcLJL1BzCgukbKzSOQRfJO8wsrY3OHT6kAxoxBQgbjOtaVC/IZowJ5get5lx12OnZTWBkE8L0ixWwazFeo+X4KWaFdDqbyJhM+Z5FyUZtv8OZEKsGOp+a1krkyjrWMO9lcoPIEIrzJgLFcjvIE8i/atWU3lrOAazE6k8/VP8v0xjH3BJIZQ2vv0fIx6s7RFCsXyJ5D1sOQNUdn53y2iLUIOL9TzHe2teOwF+QJllJkjStdQZ1JWuTGOg0TSLc367C46IpALSAQUJSLCVF3SWyJAHkq1Qw62CaBZvK9mvfA+OkAxcAnGWwuPzLEP771WprinhkSCz1vFAMlINPmxqS+G2BZHDx9G5DLMJKEN1osQ1KMY9M2ysgiLavTwQDdorPnywoQ5vo25VVi3gL79QTMPZqkauPjTANf/xlOb45wQpEclUXE21+nLcRNYlcRyPPy2PgTqwMcVRr4Nw3P87DcD2ojpJO8SMYfX7JByv16tEwgSaFP4UcDlOea+VjZsvJa81rJcxCpu9eyuUCVDkYygSJSjhQIDfxnCXMvXYwUHVdvMlvRVRPSIGYCKaXT5XNIzKfZYjcjWTTnHzD3KMHszl7HFVuLiPj5GOPaQFmCbrtfh4rEK+1YKk7dVaxZPM8T+7dpC65NqzQ6XHx0RaAWIDHDDZWaTYO+RYftQr2dhHGYnzyUYQAcHnIbJDNmSwaz7TChYw4B+cI2jFNa1sakSWgi7nM/F2FHQcPUCXzZooHtzE5CUowbRQ4R8b29RYjJOOsmmUDmHmYLZfnC03KNCylPc/eoCxNIYjC+vjFSyV7FvkwOxsdl7DLp94qiEJuw0TaWB5YikAMTqOjy10lIjExIWYAgOqe0xwG5AWsarLzW3NLSjYVGdhmIGyZ6HwtxEYhsygS+37oMxjQZ7nhoHZ997Gyj55pkgDkzgSybyEixHpI2NNjo82nnsM2XmqaY9NhAUfDWRMTLi0DcfDZv5vdtoCx/tsrB1J5AOuZss0mOXi71qoPmPgV0fq0d9he6IlALkEhgTJFGy4CwLW7zSvMM5GA//voXAAAuOTzc9ftr1pYBAD/y9TdSxyu6m5IiUIyhokCQMVAEC9s4odlYhVxLwrLIfnIpAJznkFa7LN1YuBQSJQXRUZzOlAm0ObEh1myMekKvkjzJg+0+GpmE5RpopTwUW00pKQSy6xtavqdz2xHNFgQ4CQDgbgx9/SWr+X//6Ouel7N/NEXoNrHUD7BdWwQyhUT+2JINTJQnd+mMoWVMIN05JMbWbUJvDC1sCDTIBNLI/lhj6DBO0aeKTO0X+Mx889H7T+Fbf+XvGj3X5HXR+jAaNJEOJk2idEoHk0rOUn6ulM7FABBGpuAt/wyMvL/8Oik7ly20LgLOleTPtnl/2AuwE7bjCSSVN2sTTW3G7gbqpslFGE87tIuuCNQCJN1NLb3dwCyUqqrCeUSgkmFRxnfecjV8b+97XR320PM9vP5FV1DHY3wCtHInqcFZpDi+eb2kYq5LASjemw1hlKqusS8c7Fkj00lInoVRpCv0Adn9PdnlOTORlKTyIPBktNi8yKfwKvEETJd8A08dXcMEUjKxfN+6KNGYjQLFc2YzFp9Vwfsl1xYJI9/zymfnPkZL/fmeNm1FoHQcu82yyQBZl9mF1SqN+M4XteRzZq5d3ffTJtjx1GwgRZ5ASaLrXouvgcITiJaDcUwgaed9lpAkqc0Kkw0O7Thd/H39td4KY6yQRW+aCaTcXJePUX0OvikmnYuBggXGGEOzci32e2KZRosAo0J4z498lfW1mTG0whNIU6wUMKOB8TygmJOlRaZQ2TS5GMzKDu1ivlezCwKpGS7gwASyDPxmsppFEcjzPAx6Ph4+vbnr95oCCsD4oaTj7qYiqlEoM9B0vmx+TGVoikBMrPFOnGDQ45kKEt8qwE0qBGSTylYY127CwlhXyAIybf7kovz0RjjxHjRyMGmRb2zAruzA265BzgRq1BNIxyYz57E9B0miuwaG5i3dXLhKX8t/3/O9XAamMbVuE8v9enPuRNEdN5B0+U9t7ADQzWXSiG+t0aW5hnVyuTahZQJJi7laVijTvWbYKGwRKCTXFBcjzaZNL6DJuc1VDmbbRG6NYgzJ8a4nnGvaSAfTBllIvVbM9aA8gUi5Fht04BNN1UWBWU9KWLoaOZhL81ls46Aq2MuK3hs72ffDSzsP1n10ENEVgVqARGqjpeuVzwFU+8bkTCCXfO8JfOiLJ3f9fxgnKqNCaWRmvujUdI4EMiRAmYZh6L2Cwb4whpYfP7+2ks6UMl7dFxjYpWmK1GEDCQAPnLwAAPiZd99T+ZrMjFJ3jsEU07+zW7uLQFptd1NyPwPJBkbrCcQkkrgU+vqBZ5XaREqGgrknJj2eJjGrItDuc/u4a+z3McvjNgGrMfS466iB+bu6++if/+GdAHRFIGnEd54ORo4TZpMwL0ygOCGZQOOvVBwSoGRZMGysJtPBInJNISlCzxqT8w2Tcup6Ltf1nI2psB3ySY55kUPg12PeAwupNFjbcJAWozXNW8/z4Htyc/qE/J6kcrxFgpnvJPdqlg7WjjG0lFWZNCw3+4Hf/eT4/ZANbuFz0GH/oisCtQCGCaSl99o00rNkAgHAV9146Z5JjE3yMJD6BLDa6DL6wu6mJh3MfGbJ5qVILiI05IRxdhavrux8CRdtLpvgp85lLIE7Hz5TeY44STEIdGyLafTVPRR6dZHM/jpzbs1jHAgS2sw/6z2BZJtHFyZQE7G9QHHdrHIwRQKfDYHv5eaTPzb2RJtXTCuElpGkOikYUE4ksS+iTZoaA5/onAL8BtJsEuqYUm0iIY32GTmYiyeQROIUKzyB8rlSXATimUBtG5lOpk826Tc1Wdx1TSm0PW9biiKQ9Bprioj5OYRsGr1HYnNFIEC+eQf472nezO/bgBnPZUUgHztkE0BfUJcxdbSBLtK52HgmSQz/ywh8/0ClzB1EdEWgFiCJ2TMTsZYBYaOYhjNmAn3ZlUdwbivcNcBpCiiAXO6kXfgD8sQTXTqYvPOST+gNGUOrmUCevQM/i831+e2MlVOVsJQvqhSFLGD64m3yumsj4kXabgc/GkkBxWz+2I+Q+xA0uHkEskKNbQOpZRqZ+9pmPF1EoM+WsWOuzQ2XHJrpcWcNGxsrdWACAfINzK50NSF6vswYWts0MZuEeWICaaTBoiTKWOft1SQTiJWqZHIwggkk9G6bJSYLrk1KDbcnDG01KYtlSDyBWCN8M7bbxumCCaRnj9vm5DjVSbOlaaCjsTE021zNipWyZ8CMEdLCPcP6XRSYZ25pYL8O03wjbdDaUEhN9ps2njY4XzLQlh3/YN1HBxFdEagFBAKWRUFvVzKBxgPIL/zlvfjR//LpXf+2E8X4qT/P5DeMgV0d1lb6SFLgXElq8847HoWGCS1lAmk6j+VziJlArByM0Hi/7+4nAXBFDsYYWhuvLlmUmPWWy+b60nGi3OpwejrUjmOx0mxgyp3yye9NTw+3v851YWuXg2U/PdIamrlHtfp3QNZBzdLHFL5ePZkczKVYXIcrjy4BgCrZrE3YmUCp0zNcxxosn/eIKgGOS1Nh71NTfJ5MDLxYYDepZlhsNB0syFizNraRRpKnMYbm0sE8JGmzkqxJTBa9myww/tSf3b3r/7UekgZZxHRNEWiUVDZsqo9pmmKyxqcTE8iyrk6UDQe2GM2uVySsXwOWJcIm8C0CtsMYvie7Dho5WNPSWjU7mvRAY+dLiU1Eh/2NrgjUAiSx2KZzq/G7AXZPpO+687Fd/3ZmsyjUzIoJdHzc5T1dSl46tjLA8VWenixdGIZKHwggWyzJ6L1c5xEoL0jsE4tZUF1xZEl8fLOoknSONMbWgMyLQ+NnNIlffdMtAICjFVIRs6jSpoNNS8aYXKRr2HZsRLxKDiaQLGqZQIy5uLbrBYyZQAJGnyo5Ko/3lnkCuUbEA8Af/MBX4G3je/adP/Rq/Pb33TqT4zaJQS/YI1EpI0ndCrl1hZrtcerKq55zQp0+JrpHlWma5tmXxOq2AbbIYb5TmSdQonzOzDlsx+evAW2KS8rBLkYy0iQ7p0mp4UfvPzXT4x1Z6ufs3GnQeAJJCzTaQi4gXzNGia7gLS1GjxzkYNJ7lA1qyL+bFlPrLja2Rtl9KplzVOlgsV5WKPKSTJVMo0Bmc3H1sWUAwDe/6Erq+IEnZ6x12J+Y75bmgkAy4JsCgpYJZLwapg0I5d9p5WaTMDTk9Y0RcGn2uzhJ8Yrrj9PHkppFurIsJD4HUZzQ9GeWZfHcyw5RGySG3qtlAvlCLxfAbQN5yaEhnn/5YYwqJmHDJFCn5AXFd2VC0iYXo5rJVmo46uKbJCk05Uwg8howEfHaaGkgK2JbKfrKrlc/9wSyfUfuskWD1zz3kvy/rz62nC+m5hn9wLMygVyUcnWJJOZZ+4YXXq46trRDbl6jT3Kcj4UtW+TwiSKQlglUTrsM/Oq5MFIwc/MQCGF3OUwSHOrLl6m+v3f8bxqTzJ95SZ6TYG21n63hpiBN07EcTOmRKPDrAZRzZSB7jjPDXfrw4mJ0mK9XeGauvAikK7TOSZ27FTCyxWHPRxin1DqkcSZQrLtPJV6eAHBhJ8L3verZdANLKmfrsH/RMYFagCRy1cUkLz9PaSL60tMX8v8uL1K0hqCTMEygU6UFhJaFImYC5T4Qmg0kE4HOfQbzmaVGgrTcLJCzOLKIeMU1EKQAJDO4RwHggZMbeO/dT02l7N/71HkAegPzqUygiaKEdjKXzIW5MXRD3Uc1E0jooQBkmzuniPiG0sGM4bmdCZT9nLUcbL9g2PNrmUCuCX9196lrM0NqRGnOw96nbDJP0whJH70gZ/TZX6vduLBMDiaogWXqsGmdjPfZrDBZ9PnPn3jY+jdfeOo8/s2f333Ru+zHVwZY3wzx5NntPf/2hacuqEIapIVWl3QwqbdUxrBQzMXCYnTOBKI9geyJwQZxkiifsQPEBApjsWxxOK4OM2ygKElVgTRiT6BU799ma07GSYpz2yGOKfzDzLrxYo9THZpDVwRqASIm0Ax8LMqDyP/yR3fm/90EPdl4umyOCqMxbRHIFy7cXFgWks0poGPSNO23ImUCpWmKUZRgqCzEtXGPAsXC6eSFvR3IR9e3AADPPrGiOrZh+ZS/qyhOd8nLWKZXdlwhE8jB5yAQ+BCYj6WRJAVCfTebWFRG32IMnSQpklTLlJLKwbJ/n7Ux9H7BIJB4AumPX2eSbqSAelmzbBwtmEDNST3aQBSnpBws+9kOE2j28wFtDB2TRbKLwPTaCmO88KojuO1l1wAAPvfEOevf/NDv34G3f/hBPLK+SZ3r+ZcfBgD8+OtfgF/7J7fwb3YCN1yWmdx/6uH1qe8RAB46tUEdUxqU4ZYOtneen3qOONExf4VNQ8NKpT2BfLkklQ1SmDe2YxtgZItL/exa7YTyIpk2zMIXMnXiJFVZCEiKTBd2IqSpzsswV2nMSdOkw+zRycFagEQX6qKPNihPpuWNUhNGhaZQUt5saJK1gLIcrP51kcN31PN9bEZ2Z/ztMMaKMg1DlD6m8FvJI+ItA7Exu1se6AxZ6zaOQNnvZjab62nPhNGxX69MYJrWaY6SBIeX+ti5kMXTH1d0RKTRw7lvUkNMIHMNNFcgK/TZXxclKZb6eiZQ3eLZfD86Np9MDmY+4ywj4vcTrIU4R2PopplAkgVnISVpxgS/LURkkUPaMAGyMXBA+rkAcmarRs7DJGlm5+DWFLncrM0i0CjGV954CX7im74MpzdGePr8XlbNJMz73Njh1mYnDg1w69Iafui/u0H1XifxquecAACcniIJM88hW0zgmUDNpYOFcarywZQwo7Pj6+TrEnWAQUz6Gl2MZ+BiY2skl4PlCZFCJlCaGulYs+lgTYWJmP3fimZfUJJ2KqaSDvsAHROoBUge1Jzl4rA4Ly+WTm+E+J2/ewB/fc9T+MyjZ9XHtJ1rNN6QJUk6Hig0A1n20+6bpF809ISdnS2FEWIg1MBnr+GMQIHSwtmygzeMr+W+cjKRMrFmxLD4yJf2mly6yiLLfhYGYZzuSirSRFdLo4fzeHK1frz+HOYKqUx3PVniiVZGAmTPWV2RpmDz8feoWA6mlMwtCuzpYG6y4LpEkjzgQNnMCHyprFZfTGSSeZpEGCd4/Ow21+XPPYHsr52FJ1Dt8RXXwBfO9cU5Emq+7wkLELNCkqTYiZJ8zbDcD/YYRRv87b1P4+7Hz+IPPv4QvvBUJtf/pffdi40deWzzTpRgqJjfq2AkIn/0yb0SNi0LQCpHcmICCT2BMnZ6c14uRRGI9wSSShZpJtABjYiXysFMsUiqkHCRLQa+LJAmK/TRh8+KiZamWL4vIL29ALlfa4f9i44J1AIk1WAXqZNB+W9PXtjBv/3/7lEfy4bhWCduNhvGd0VXBBqnXzUQSWvQ8+s3pwZbI/lkYtAXUpOBbPPCXuNiMVb/OuNNoJE7+YIUgFmlLpnn4V/818/gO8cU+slzqIsQ05hAcbIrkl4VXR0II+KVHgSALO4zcShwSCWRLp5Ats/gIilk5GCB783M/2y/YbkfIErSSmlr6igHG/aCSnZpPkYr0+VMBz5N09rrZ+4xrQfdPCxqf/OD9wMA3nPXE3jrd94s+htz3cTpYA6eQOKgBuIa5A0NqTE0a5xNeg65wrAJjM/IUj+o3Fy++e2f3PO793/+afztvc/gW26WpfaMokQ1f1XBjA+ffewcNkfRLrbALc9ew/0nN/CmVzyLOqacCaT3eJT6VunTUmWbd22QBSNJTUg/Gt/34HkHa+O+EyU4NJQ9F2Z9LzVwdylWGn8+G+OzSSaQ+ZxLCqf8wmT84NxLBw0dE6gFBL6PNK2nZ5pKsFuHtr3L2Z/oyrt0gM3YaNd3u20gJZPidpjQRSCpsbV5De0JlDONLEwgM9greJuSQmXiIHUq47ff/PLKf5sZE6i0OJyMJNeyaCRGi3Gif+++gIJeGEMr9OmebPOYuBSyAr+WQWD08ZpCIiMHmxVbbT/i2JjpdmZzeupPkrj5JR1b6WN9c3qsdD5Gq5lApiFQ/zqtMbT5m3nYIJ0ae6Kd25YzQfKIeIlvkrKYO20MnXp8jSeQcK4vzpHkTRYJ2o6IN74ixmdkqe9PLZDWScVPb+yIz6dN/6zD//kPbgKw1yPlxKEBBj1/V0KiBPk1sN0/Dv55Zi6oM8A359D6VEqbegAfZMFIUjVhJZKG0iKBYS+b9bHUJqNoOPD3qQnQObs1fb40iJJUtSbqBXaGer4vUHphAgdLWnjQ0BWBWoCEuqoZ6CfRpgeG0VmbTkik1EYDcrNIlwJBEHh7UqL2HD9OMIoTWg5mJh9RBL3iOks9k0wHUlMEYiLiXe+zuu/XmQk0RZoXxtxGYhqkG0cXU2WJZNHcwppT1EV7l+EyFvUti+fIofsrlYO5FLEWAcbz6nRVEciRCbS2MsDnK8xvXQybAUIa7HAeJpmnSWhlKoBcDqZizQqlNrGDJ5B4A8wygVqWL5gihGECLfcDnNoY7Um+3K6RZ372sXP4xAOnRV5CO1Gcn2tWMMebLKi4hEwAhCeQ4h4dTvGknIaRUg7WE8q1zFxEG0ML5eUAqChzA0lDaZGQFbxl18CsP7dGsu+/2Hfwz4KxHqhqmhgkaXMR9GfH52b3Neb4wMGSFh40dEWgFiBhisxi4/Lw6fqkiVk2x3uBD98rJuGRgyFosbCVLRo0haY+QZtktbMM/TbSRMQLvx8TeakpAkn8YmZlDH28xpPHnQm0V5rHSgqmH1e2qNIs2Ax8gVdJ4sQEkpsUaq9xYNGozyIRxlYEcpGzLQLWVvsAgPWN6QtPV0+gwPdwbjvC42e29vxbbgytlYNJpcFOKXzyZJ4moRmTODmY1szUmDcLPV0Y01rSr4SV80xrAjQJw54xRQlzP9712G4fxiqJ2GWHh/gvtz+CN/7GR/EDv3u79XxNMIFyf8eJgkoYJ3T0OZCNLUzaqOYZNt+BbS5wSayVMYG0EfEyeTmQNU7YxlLHBKqGYe1J5WAujcljy9lcfHZrekPGQM0EEtyn77vnSQDACYUXpk8wTzvsT3SeQC2gMCtMAEzfoDe9cfE84NM/+Q0zPWY5haaIytRJbQCJMbSLBMBuoHZmXDE/pkiP6gvTHlRyMCk938UsVcBCyVOXHKuJz73sEF541ZE8Dn73Odz8XKbJAbbDGMeW+7jz/3id7g1DHq+uNfgDZAs386+aryfwZZO5izF0P/BqF+Zm06TpSvWFC39Xpst+x/G8+zh94Zmmujhag699wWV4911P4OxWiKuOLe/6t9BZDpb9tBq+OnjQMck8TUJTKPMIpkvk6AkkkWf7HtcUMB+Zk8IQRSbCn28WMI0XY9b8+hddgd/44P14/MwWbr7mWP46Iz35jpdejW/+8itx3SUrWFsZYGMnxiPrm3j7hx/Apx85IzhfkhecZoU86XUKE0iTrAVk86WNee2SDtafYKJXHT9JtWOETK41yhnw/JpOIi8HdBJzaRFrURAlidg3SVrkLh8bcDMwt0nYE+WaS2JzMYpSeB5w4+WH6eN3nkCLj64I1ALaYgLV4aqjyzg6rkrPCoOen8eSO8nBhLpTFwlAVjGvH/RNTKo2QlyaJsEuesxtYRuIzelVBQIBfdhlMpzEi689hqfO7aW/axNtDPy801xc6+0wxtIgUKWCGbTBBJKcw8UTqCeUwTT5GVzMy/vCBZXL+18E5HKwKbHPgHtEvJlHphWlI4fiDFBs4q0FaYeCt+/LmDRNQ1fIzf5I8vbjFjyBeK8SrkgTxZwpbttpNmb9YyRVVx7NiqKnJ1h4Ztz7+i+7HK+96fL89ycOAc86sYKP3ncKH7j3GSQWRkATTKBJaf8sztXzPbsnUMNMoDBnp+sakxK5VhiN16SsxN/3rEEfBnGS0J+hYwJVoy+Uu5aPDbiFWUjW1prmamBpugFZM+imK4/Qxwbkc0GH/YtODtYCJJ21aMyAaAonL8jNBxm8845HAZQnXF3XBRB0HvMiRDMR8aZzrikW9HxZ8pJmg1rQq+0MCEDH1BEZQxsm0Azu074/Pa0tjvUsFKCY4D96XxE/vx3yPk+TkBTJALd0MEkRyPyzSg4mZAJpGQSAMYZO93hiGORFIA0TSCoHU8pgFgWGybheWQRyM4bOu5tTxiMXNiIAmL2O7TkIHWWF89AlN9/RtceXLa8swMjBWBZN/r4ITyB2c5ozgcTx2JyfGxPSMAvkTKBxUeLYyliKOcHC++AXngFQLTVfWx0gTlKct5iEZ0yg2XoCDSr8df7004+rLQQk6VeJ0+Y6+5tfet8XKl+j9esBjHGz/XWjOEbP92gpD8ME0jTG5sX3rC0w3xE7RrhKjyXnSpSBIrZiXxgneP/nn1YTAMxeYh6aJh2awcFdKbcISXdzFt3rX7ytOmZ2x2Kgp8Glh4Y4PI4rHUV6OVge6yr0gdAuGmwMAvMdGc0wg0Dg0g/ozTolGnIX4+ZBz7eaLJrro2zy70Iv8KcmprgygV5x/XEAwGbJg2ErjN2LQL6HJEVlccMgSfQsi17g55vbyuOPz69lezXtCWRL53ExLxfLwZJ0JvfofsWg5+PQsFdrDO2i6DSb8mlF79CBEQoAQSBkAo0LlRrZqO/Nh8eBieN++5tfIf6b3PhYyOjTzDUmSnjH4pmhGaulnXEgu0ZJyjE5Wi8CTXgCLfUDrA6CPSw8Mx+94voTU49zfOzjVfXMAtncM4obYAJVjKuHhr3c04RFXxBC4MIEkjz3ZnzSGrCLmEDK9DEmoTBO+LCJefE9awsME6hXM39VHRvQergJ9zZKEoCt2Gqa/8+97BB9bHN8oL3xtEP7OMBL5fYgYbq4+HAzVxHgAAAgAElEQVQYPE+h+XTBq597opCDOcgA8mqzdeGvH4wlyUjFoqE5n4lIyXSRRJS7GDcv9QOrUZ75/lxYBAa9wJta8HB9Dg4v9dEPvF2fZWsUq+RHZUgnQ5dibt/3aqOEgUIGojkF42vkms5W9SxstyEHc0hoWxSsrfZzj7NJpDNiAlUVccuvYSH3h9M/Z9lYPfumCAvzHq44uiT+G3PdJI1ZbcqfiRKWzAfsOGFeLjLdVawpdvsvNo9cDlYqaq+tDvYwgUZRAt/LCivTcMwi4QTKSWSzNoaezgTyPOCWZ6+pjilhApn1jOu6twou7HSpXGsU6dLHpMxiQF9sPXhMINl1DgJujHBJB8vXjdY1SzNMIDOevPqGS+hjA/JQmg77F10RqAVIBoLIgUFgoO2+arHcD/LOvuuEC8glAHomkE1G4mAAJ9DAZ+dI9YsSy5zlkhy1PAjyDbrt+LOQg/UqCh6zkPIsle7Lkxd2sBXGKuZJGVKDPBc5WNlovQoFE0jXNZLJwVwKWfWeH7OQg9kYa0nC+YgsIo6vDCyeQPpj58W4Kdc4nweUz3BP+JxpO/BAViSXJvM0iVDBbM3lYA36k5ln0zYfaMZqI20WjUOK76ftTcukHAwA1qY8e6GFwXPcIuHMztVMEci8r52Jh8KlWNwTyJ1ck0BtGDnKwSRyLdt1rYLEnsAgUTD6GKbRIoBjArXnCSReN6qZQPXNZ5MQWpfIW3987rvqsP/QFYFaQE9QedYM9JN4/hWH8aaveBb+w3e/dM+//UKNVEyL5TF7JE3TXA6m6Yr4Qt1p0Tlqhn6bR9Arjy9iAin9ViSLEpf0ruV+gDBOa5koudxsFkwg30eS7t3MxA5+NAbL/aKg9dlxVO+lh/Sm0IC8UJk4FFB6gd1XqmAC6Z4zqRxMe40LI8Hp95Ep4KjGCd8T0fQjh/e/KJjGRjBwNYYu6PTVnkCa6wuUpMFW82+9h55kg9oGNMxTRg6mnWtMEcjGBIpi5VwmHIfyIhDx/bRtZGoKM+VCwOowwOZOvOd1dcUIW6IfUIydM4+Ir5DHuAYE2JlAqVMSqA3589VrRn4POETQ00wg3nj6IG3co1g+H9gk65MwjQ0Xk327yqEZJtDmKPMYW1Ey4X0hM7fD/kVXBGoBkg2kqxeKOc/PfvuX4wVX7JaF/cJtN+ONt17rdOxpMLTxnSjJN2bargsA66QbOhi02QxrgZIBnEpuJtOQuyS22NPBjByMPnzR/a1hWZiJTOsXU0ZVQsMsnoMyq8ksnF/6LB2t3UC6cHApQAwC3xqrW7C9+OP3AlkHPnZg0tiSN1xigc3xbRu8ONV7Gi0K6plAOiaZQV3srRkDNWxHgGACJalToWke7DLiJIHncfNZnqQpeP9qJtDAMIHsxVatv52EqVPIwXgmUFtSmGnsnP6Ucdzm5bMmKAI1xQSqWp+6eIdJ0qlc5/of/JobatebLqxEifw+O0eqYwIRRRqN7FLKtlsUtOIJpCx4AzKTfVU6mMVCwEUdYI4PQGSS3mF/oisCtQDJQODSfZ/ELDxbJDAGkvc+eX4mcjBbESVn6jgkkNkKceXXsseXMYFcjATrX5MXaRTXP/eBGFV3f+NZysHG38H57d2+JVoz0zKWS/5GoYPPUxnSjkjiUIDoBV4eOVt9/OynB6UPQcOeQIFlgRU7FCqBrGs9sknmZuCvtt+xtjqY6gmUpin+6p6nnJgw5ll6391P7vm3/HlTfv85E8g2F8Q6vxtgfphAYZKqWKe+ZzeoB/TpYEY6WzcXAPpxItu4MHIw3hPoYkXEA9lccefDZ3a9h7++56lav5/VQYBB4O+Jli+jKSaQmW+nFYFcGKEiJpDDWnXQy+aCqmfBzBOq9VYgW8+NtEwgQq6lsYqQRtzvNzx2Zgs/+f9+FmcmiqUR0bgKKu73KrjIFqXyVG3jzVZszdUBDqxZoD2PtQ7toysCtQAJE2gW6WAGV46NJm972TUAgFdWJFK4YnWYLXze8LYPO8nBpAOly2Asib2NHIwKe74v9ARSan8FnSmXIs3SeGFZ5wMxSw3/6rjo9IkHTu/6faiUGJSRmVxn39Uozj6P68K5aqE8CZeFbcZWsxlDG08g/viShWeapk5spoIlMv1zODOBenbfpHgG/mr7HWsrfVzYiXLPEoP3jgs3X3jqgvrY5vl8152P7fm3yKEZUD62reDtwiJgTFmbxNYoVrE6JFKSJEmRpjozU/OetqPZp4MB43Q2CRMov5d4plRbUhiToDYsJYr+t3Ec/B9+4mEA2bV4+vxOLXvL8zwcW+lbPIHGc1kw24j4qiZc4uQJZF8PaUMyDIZ5qtn085gi4kAhB+sJmTSZMbSuKUl5AimYQPPgezZrvOat78d/+uhD+JE/+vSu37fjCdSc36l23WgrVrom+vrCvVmH/YvpUQUdZgpJAWKWRaDVYQ8PvvVbAAC/9I9ePJNjTsPR5cJnxUkO5gkX/rFLkUZQBFJ0Hg3knkCpqkvORMRrFm65OaRADjYLxtpX3ngpgL0bje0wcU7yWu4H2DaG5ZFZCLbDBIoTvVxuEPhW0+PcE0hdSJQxjbTm3LZOfH6PaplAAjmYy+ZlUWDkJWc2Q1x+pHieNi3sDgnqNj2u6WC+N31DOgkXTyBp/HPTOLM5yq8TA9/3rHIwl+uQP8M22aWSjSUpdgPFZ6DkYHl62sWTgxmYgs657Wp2TxnHVwe1EfGjhuRgVWN2nOhZrdJ0MBcDf3NfVEntXOVgkvXcdhhjua9bL0oli5Hie8qMpy/+GNcU7nu6aGKwjSubb+EkComzpuAtlIOluoJo369PPXZRBwDyvVmH/YuOCdQCzIaqblDWDgIXE+X36yIHM3N0kxHx+TWoWdjmxscNeQLFDt1ZiTG0S3y4WVjWFSHy72cG92luPjrafb6tUaxKjtp17EEhB3v0zBYAvVGtgdSrJElTdddFIil08QRizNG1m3jz/Fc9C3nCnEOH2SoHS1N1kWlRYNKGnjq3jcfHzwAA55Q8Gwo5mO4CSD0I4lQfLc0k8zSJ05uhrggkkIO5jNXSRBg9E0jGUogUm3i/5U1Lbgw9ZdA330ydDKyMtZVBLROoKTnYtOudOswzgKwIoZUrGpjvvGrN4iQHEzKBtkaxqmnFpHdpZJfSEIj9ijLDlW1cXYx0MOveJtYVXE2xtWo+cF2zS606OuxfiJ4az/Ne73nevZ7nfcnzvLfUvO7lnufFnufdNru3uP9hmB9VtFVgtkygtnDt8ZX8vx88uQnATQ4miQUGdJ2dwrC2ejALneRgEiNEfUehJzAzdRnwzcKyboM9SzlYVQLNLOLcjSfQKErwH/7miwCAoSOFPpcZWFOL9FKqfs8XsVwAXWdHYsjqumiwLbBcjz/o+bXjKODmZbEouPLYMgDgX/3JXXj1W9+Pv/zsEwCKQvEJZWQssLuQNLn4jBQSnjKkHgRxkqhZCkwyT5M4uznC0eU+/XeS9+8ibTYx7pJzaOcyyQa78HNj5GDZz7au73aYSfqmGa2b+/PM1myYQE0ZQ/fyJmXxnbkmgTLpYFr0cznY9LHCRQ4mZXZvhbqmFVME0size4K5fj/jqvH8BvCyUen4ZuBkQyHc22hJADbmdWcM3cEG62zieV4A4G0AvgnATQC+2/O8mype9/MA3jvrN7nfMewXKVpViJSpURcTzy+lkD18OisCaSdEQCK10W8wJN3NOC8y6TyBbBv4yOH4voAJFDsM+MZnYKfGE8gYzR5b4Tcuk1gaTPcg2lYuqnYdux9gaxTvKmhpYmLLMNfMtrDKmEDKIpDv1Rpdls+vOYN0Ywe4MHXqi2WuRaBMDmZjArmlXy0CXnzNUQDAZx87BwC48+EzAIqi6x/+01eqj33p4SH+8ThtcrIgFzp0TQG5B4GT9xYhxWgSozhVp2laNxUz6ABLNvFqY2iRdJpnAkn9BWeFM5sjrK3UF1TNHPe2N91S+7q11f5UM3eDNplAebPBoRlgXQ8lenN3wM4EcpKDCYso2qYV40umKZb5gu9/P+LyI0MAwE1XHsl/Z/ZVzHWQjkFAeV+gMwAHZJ5AKiaQxWqkSAzWzgPj9zcH82WHZiC5q18B4Etpmt6fpukIwB8BeMOU1/0wgD8G8PQM399CYFmQthE7bB7nAafGNGYVNVbot5JHxCsW/0aeUDfwhw4LZ9kG2+H4gkWDKR5ojm+MLeuYQCa+1rbolWAQ+PC9iiKQqyfQwMdOFCMsLQ41m60yxBIJh2KukVLVXWfzL5oih+QeNXVGfZGm/jlzZxrZjaHTNFXLGBYFnudNZfuY521t1a2Qe8NlqwD2jhfR2NhdW4STGkO7eG/NywZJm2Injd82r9VAkqAWKT2BxBHxZvOl8ARqiwl0eqNa0meaMeZzXHF0WHustZUBzmyOKt+7kcCUk8hmgcIDqrjes2AQiMxwXeRgFh/D0FEOJvIEUsrXGUmqJjF1EZlAaZpifVwkLTPIzZzGXAcmIdJ13Q7IikBNMIHydDD1c5w9OxLmZof9CcnoeDWAR0r//+j4dzk8z7sawLcD+PXZvbXFgdnU1iUv7Uc5WBkfHCdiLCkWKIyDvu8pTXEFZnBxot/A9AIvl5NVH9/Q27WeQLbvJ/upYwLZPYHWN0ZY7gcz8RXxPA/L/QC/8v4v4bq3vBsfv/8UgHFnzXGRO+wFOHlhhJf+9F/lv3N9tsx3atV2p/pkKnNf1MmdXNLBJBHxLpJFwP6cubDVgEwCMBLIwQ66MTQwIdsa//zTcaLXysAtE6JqvIgUG5YypMbQiYOH3rxskDSGr4CcpZO9Vu/N1JScR8wEUmzi206zWd8cYa2CGWu+mpzBY5Ekr60MkKTAuQr52E5TTKApbAIX7zlgzIxuyROoqimgkRMaSOVCaiYQw0RRPGfM8fcLNkdx/ix9/P7TuO4t78ZDpzbwnf/PRwBkzT8p2O8fUCoQhKmyUaJbswSW5na+3lIOGYG3d2zosFiQ3BrT7szJO+L/BvDjaZrWRo94nvc/eZ53u+d5tz/zzDPS97jvsTRmWUz6n5SRDfT7z830D3/gK3b9v6ZAI124ZRsMfbQ0UL1gMMd3oc9bB/rxuZtiGrkM+AOBMfRO5J7cVcaRkh/G73z4gfz8rovcF151ZM/vXOVBUjPBxOEeMovVumKii0lhJimsf41LwhxQjoivWJQYNp/WE0ggB+si4jMsVaTWDHs+Dg3dikBV4+mOo6eXuX9sTdpISZ8HxkygOVjUusipbMXo2TCBmvEEkpruaj6D2bS0VQTaiarvdzME5YwUiyTZPJMbo2jqv5vi0JHl2Yb6TmMTODM2BUwXl4Q/wL5mcTJHF8q1olhX9B4EgTUJND+HQjbHeN7sF5QZX0+e2wYA/PXnnsaj61nwAcsEkrJBc4l8g0wgF1Zo3fFdE33b9ljr0D4kI8ujAK4t/f81AB6feM2tAP7I87wHAdwG4Nc8z/u2yQOlafqbaZremqbprZdeeqnyLe8/iORgjl2Ri4WXX3/c+RjSgdJIDTQoOtfV54jiVMXSAYSeQA4L88wHov41uRzMISLeZgw9y3u0LCvbCrPzahdVZbz42mNOfz8NYm23iyeQkVJJEuzUMhJ7d9a8VoNpJqNlxA73qDm+TQ6WpPrO1yJhWsH29OYIr73pcudjVzGBXJl8YiZQkkI7TEiNiZuGtumQsSws45BjsTUQnEP7/rP4bfsGWJM42nY6WJ3817yXUU2CWBlLFsb46Y2sCDQLOXYZdZ5ALrLOJqXTQLFmqZoPnIpAQrlWrAwhWB742Apja8ofoGtqSIq4+w3Txozys8J5AtnHN4NZpIPZGdh6VmX297N/Bsp/Nw/M2Q7NQDK7fhLAjZ7nXe953gDAdwH4s/IL0jS9Pk3T69I0vQ7AOwH8szRN/3Tm73afYqkiCakMLR3wYkNbNCmDGSjVRaBxF66uyOEiyRN1TnOPg2Yi4l1YHCZxZCesMy/XF+GmYaW0Sf3gF57Bh790EmGSON9Ts14kA/aOi0Hi8BwXLJpmEtp8oU+D9vhA6TNURcQnKTylpBOQycHSTg4GYHdn9Lc+dD9+4l134f5nNvL4eBeYDdjP/cXndv1+K3RjC0oN2GMHU9lgTuKTXZhATSZRAuP5TBB0oH//9tdFCjmPuSXaKvJJZIlSQ+eiWTj9y1nfHOHwUm8ma64yphXui4aS7phSTyCXho/5Hj5w73QbUhfpsZQJpF0zLvcDxElqTbo052C/p3lJQJwlpi0p/tu9haKEYQL1A8ITyKGgLrUR0AaKSNPBXD365mG+7NAMrLNJmqYRgH+OLPXrcwDekabp3Z7n/aDneT/Y9BtcBAwFUhstHXAe8B23ZBZRP/q656n+vi/wowEM/Vy3ADJ6/LpzhA5FjkDgCWRo3k1FiuZFIMVnyE0WbUUyR5ZOGbc/tL7r///Jf/y4emNRxpGl2dLlgRITSBD1qU8Hs0sWXSnutrncRf8OlE1Gp59IE3dbhkQOlqR6OdsiobxZTFPgP3/iYQDA1WvLVX8ixurYU+g9dz256/dbIzc5WOEpJfDe0voczBUTqBnT2vbSwZppaABu6WBtpdlM6+D/3v/4CgDZMwcUjScbE2jZ0izc2ImcZZzTYN5++Xq7rCUAGVtNe/8bmDXL2z5w39R/dwnKkCYIpqnuO5I0hg00haZeMB+F7lliGtulvF5dJZ4NxhOoYEfz92rfIo8vn8OJCVRx/MThGQDkRawO+xeipyZN0/cAeM/E76aaQKdp+mb3t7VY8DwPvlff3Ywc9dEXE7/8xpfgl9/4EvXfB76HQc/Hdg0LBXBj6vQFLAuXzpSECWTStY5XpInUQUKhdxnwh5IiWZLmhYpZYHUQYGNCIuni+2Tg+vdTjymVgyUupsf2BUPssCBhEuzUbKbcqLDaGNplnJPIweIx2+ig49U3nMBH7ju15/df8zx3KXZVItJ2GGO5wotIAin9PE5S9JXnmRfT1Ln2BBJ0yrXG1r5A2gzojH3bTgebdg1ffl0mkTdNITETaFDvHelqul4Fz/P2FObM19d0OphLw8f23lyCMnzfQ5qOmb017zFWJlEatuROGAPL9UmNUcI3J31vPgrds0S5sD3t3mLW1YxcLnbwBPI8D/3Aq1UgJEmKNNUd357Gmv3Up4O1O552aB+dc0JLsHVG9ns6mCuW+0Ftehow9uxRy8HsbCONAZ+BxBNofazp1xSBJEaLxcKNPrzo+3E1cpzE0YrFj/YaNwl51KeeTZYXUARyMM0pRBHxqb7IBBQbto/cdwoPn9rce3zHca7f861dtdSx0LTo0Iw/kygzEk5e2Mn/eyuMneRg0/xJpsElSEEaUd40olg3nmZ+KzJpcNPpYPqIe4IJNMfpYJmvze73l0soxuOUNKp8yeIdGcbJTJswZcRJivfe/VT+/64R8ZJ71LXxubkz3UDbwCUoQyqDiZXMVsP6euzMVu3rkiRVMVsDIZNpP8Fci/LcE5bWq4wNQOAzxtBuBfV+4O96n5Nw8UksijQV8nvXdLCWmZUd2kdXBGoJtg1Y7BB5uwhY6vu1xtnAmDKp7ISJjI9jXdoJIOssnN/OikCHFXIlicbbxRMol4NF1dcgjN1ZOmX8rxPyQUOXnzWT51nHV5yPkTMURJtT/WIBsDGBsoWzRuMt8Tlw0b8DxWf4Tx99CF/9ix/Ye3xHOVg/8GTG0B0VCK+76QoAwM3XHM1/d8mh4UyKQGVJ2Q//4Z35f2+NYpXc1UDaeUxSvTH0fmcCSeaC3FRZKweTjBVaCYPQr8SMg6p0sIvIBMrG56KhwnoCVTXDZhGaUIcvPX0BpzcytnLBKtYdKxB4SrkygW68/DCA6vvDJRnJFPbqionm+Bo52GWHlwAAn3r4TO3rzDjFxtwvYjqY+TxfduXh/HfmfgWmByFUIWvKyzyBXCXyg55v9SIFoNrb2IqVscMzAHRMoIOArgjUEmyRhHGsj7xdBCz3A6s+OnKQI1Wl2UweX+2hEEg6X/qOgkSjni96lBKDnu9ZmECzLVS+8dZr8eBbvwUPvvVb8MKrjuAlz8pSvdgFTx3u/9lvxgd/7GudjyNlKCRKjwBAKll00HcL7iFXLxHbQsxGr7ehL0oH01H0Fw3Pv+IwHnzrt+Cl47S8/+21z8Mn/tXXz8RY9tCwh++85RoAwIOnNvLfbztGxMuTIh3G6jnZIGmbGrL47eY9gVyMoSX7ryJIQX6OPB2spcs77Rp6nreL2TyKE3iefd43Y2e1HCxRMzSlMPO/uX/UhrICTxqX9RYAXHp4iC+/+ii+ukLe6uSf5xfvsQouDI6br80K87Z0MHMvLA+4xqG00LqfYMaD73/N9fji//VN+I5brs6j4n/xtpupY0nG0Py8DhJ8INt7iHweHZhAVXtL53mgZXlth/bRFYFaQmDR2HdMIEERSEmfB+xxotnx9ddAEoma5tRMnUbdRl81p9dW/Qc9v7EimeTcm2Pj7Fk+B7MqrEppsRk9XHeOXq7vrpfkudyj4lQh5TlsBYCnz+84+fX0e55VDpak+s3LImN1GMy00TBNMpJ5ArXDBFL7lczJBsnFE0iywQZcPYHs59AmXUq68LHCGLrtdLCq8bjc1BrFWeKlbUyyMYHCOJ1pg2QaDBM4dVxLtOEJBGT3adWaLnFYbwVTEtMm4WKeLZWbmXthifQ/m5dC9yxRjmrvB/6udFk2EVayXp88rws7eqdiXX1hJ8q9QlXS4KB+vjR7Du16qIuIX3zMPmqgw1TYBp3YsUO+37EyCPIiQBVcihCSBDJXTyAJ/RlQVvw9u49FnA/49OEB2GmrUZw0tgjtBz7ObmVyuSaMnV2Rb04F11jrw2G+21FUfQ4XOVWmg2/OXBywJ9995L5TVu+vOvQtXTVgzDY6uEPpHpgF4Kwlcrc86xj+5M7H8JxLV/PfzcoTqMl46YDoAjeFNE3Vz7KkiOW6cZEZsOsK0plfif11KmPolj0sqtYk5abWKEowFMxptsQol3RUKcy5iwKH7jg9v34tAUz3U2JRNx+4+BqZW67uOTO3mOb4Ev8/oPCHYgvr/pz4ns0S0YRBc/k7ObZSb649CaZIFilkqWUMa3wMX/bTf5UXiHSMNYsxtKM/ojSts8P+xfztthYUtkEnmrHUZr/h2MoAZzbD2tfESaqWMkg8geLEwRNIQH8246iqMyU4vtn8aqv+g+DiMYGGPR+bO9mCZxaFpjv+99fi0z/5OufjGFBMIOWo2hcwgRIHX6ylflDZkTJwXfDYrt2hYQ8vHcv+dMeXycE6Y+gCw9zvS+aBIMX3vPLZAICbrjqS/25rVkwgQcF7PzOBctZmQxHxORNIPVZUd6/L59BKjxszhp6DdDAgk3btjNNOwzhB3+IHBGTPqecB25XG0M2vEU3RwdUYeqlffP4qzIIJlEltqqQw2U9VoTUQMIEcfJOkTKBcDkaOqUz61X7BZDJq+TsZ9tjvxx7kUpw3k3PqZf4+RhVem+UxVhsSkL3H6mfAxYOxbaP9Du2jKwK1hC4drB5rgiJQOAM5WGOeQAKKu5NnjyDy03XzO+jVL/yjuDlPgkHgYyOXg7mf48ShIY6RFOE6iBkKDtcgLwLVLE5cisXL4yJQ3X3kQnEH7AXIOEmdjLozY2j7c9DJwQrYGAZaeJ6Hw8NePqYmSYrtMHHzBCKYQHqWy8VPzikKHDoJgN2gnpdSlSFJ63SRs1nquACUxtBm09LSBjiqYH4uTzCBBoJKgfESqmQCjWVlTWJ7XLhxLQIt9wOM4sSSdJmoGxoGMjkYf1yJF4pLEIfve/A9O8Mil4OR7Erfmw/z+1kimlg/l78TdhyVSlLNeV2KlTabhfJ7YlF4VVY/Ay7L6c4TaPHRFYFagjUdzEHmsQg4vtrf5fQ/DRkTSM9yAWzpYHrjaYnG2MVIULJxiR03v0PLZOUiwbAh8D2c3x4XgRr2PdDA1nExcIlAN+ewJUnoTZuze3u7JgHO3GNNdZyjxG0j0w98xElqpel36WAFrjiaJdGsOsi0qjDo+fjUw2dw80+9F//+b76Y/04L6aLT5TnwfQ9pyhcKTl7Ywa0/81d43r/+C/zuRx5UndvAzbS2vqEEuKf8LQ+C2rTOx85sYXMUO6QUCphAuRxMfj/l6WAt7VmqCmFL/czj7j13PYF33P5obmBrw1I/wGbF9x41OP8afPdvfQyjKMm/P3URKJ9rmg2a6NcygdzWW0A9I9GlqQdkDDcrE0gpB8vM1xdr4z45Zpa/E3ZfIGHul8/r0lwd9nx84N5n8OefeRz/+k/uwtf9u7+dagjudJ9WMoHc9pXSQJQO+xddEagl1BUJ0jTFTuTWQd3vWOoHtZtTwC0RJo/frvVb0TONer5v3VgUiRv88X3fHrmaOA74g169XKhJyeIbXnJ1/t+ves6JRs7hAqnMwMWzR8oE0h4/Z4TUbO4mu20a/Pr3vAwApjJ+RpFbEejwUqb9P79dzRqMu3SwXXjjrdfiZ7/9y/H9r7l+5sfuBz4+88gZnNuO8AcffwjAbnkYi8BidGngMtZJNnjT8MDJDZy8MMIoTnDnw+uqcxsYqcxQUTALPFmRDHCRg9UHNTw0ToR77mWH6GNL/TiisQyDGYvMLdEG0ytN08oN4rAXYBQl+Mwj9RHgk6hLEmpSDvarb3pp/t8nL+w43Z9AsUGvm2tc/UqA+u/LpdBqmLB1a65CDqYfh2yeQMYn8eiywvNmwSQ8k2uTchGIZTwycjkXr1AA+Jff+HwAwL1PnscffPxh3P/MxtS9oBsTqLoI5OI12zazskP76IpALaFOBx/G2WLCxVBzv8MUUep9k/QbyMD3EPgeRnH9BtjFE8gcowounSMRE8ghPhyQGEO7TYZ1ePl1a/l/X3ZkqZFzuECcWuQw6Uoi4l09gYB6WVDsyCAAgNe/6Ap84wsv35XeYeBaSDy+mi2G12ukoxpLQhUAACAASURBVEl6sFmVkwh8D2/6imc5MXSqUD6mYVteu6aX+4kj4h2ZQJJzTMIwVXu+h9MW6bINWq8PIGMCSb4fwC3lr04OZv7t+Zcfpo8tLQKFCmau52UymzY2LXHNdzwYm8Ha2M2TyMz7p7/3JuXYX/XcImb99MaoFE2uW5MuWZLOgGyuaTIdzCUZScQEckxekrDHT4+To46vctL2xUwH251cuuwkB2M8gdyKla98zomxOXRxn067Nppz2BqHqYN3HlCajxesoNihQJcO1hLqJvetPAbyABeBShvgwJ/+PbgOxjbjYxd6sqRIkJuBKjXkkthkl73vsMbADpiNhr8KrOa9bTCeQHpT5TFbrdZHQV+Is0UQm+MDbkUgwJgh7v0cUayLlTYwUbCnN0a4/pLVqa9Jki4ivi1Mo+FL/E+qIDWGdvE/k0o7J/FX9zwFALjh0kO48+F1fO9vfxwAcOmhIX7htpup+9plky3pYhcsCP1YUcfi2Bplz7bm/UtZClGsC2poiwWRj5VT3mM/8DCKEvzppx+jjtmvkak0KQc7vFRsBW779Y/gq2/MikLaNam5L+oaDlV+Sgz6QfVm3oVpVBSK6xoy2U81IzHwrb406+MiIp1+NQfm97PGpMR1aZccrDkmUBjrUhDLGPR8nCoVhKMkxTtuf2TXa1yYQFX3qSvbzvc9eC0V1TtcHHRMoJbQq4ml3cmLQAf3cvQFTBpXOvSgJqoRcJObifxccqNCJROoYWPooSURpkk5mEuiUBuQbk4jJyZQfdwnMKb3Ki+BYW1s16S2mO6ma8d5GqssTVOESYKBw0bGFIHWazrsaScHaw2DUirLhZ1o/LsZFIEsXVonTyBP53Ng7rl/+tXPwY2XHcLGToRH17fwrjsfwyPrW9SxTIFFs8mWmJq6MoGMQfE07wrAjcnUq2mIlaGdb3xBiMIsUM8EyuTtZr3xM9/2ItEx6woDGzvRVHblLOD7Hr53nPa3HSZ437jgqZ2XTVpTLRNoRp5AVWsul2SkolBc/RqXdDBzDttzcGEnxiDw6fSrLCIelc/vfsSkxPXwsChcsvdRlrYrM4aeRWjPsOfjnXc8WhwzTvFj7/z73e9JuS8A6uRg7v6IwQKajHco0DGBWkKdmaPLgmpRYDaddRrp2FGb2w/qixyJA3VyKEgfczENlqQ9uJrAWSPiG5SDNZ164gqpQZ6TV4lADubyDBSmqfWeQ4B+YWswzWQ8TlKkKRf5PAlDizc0+WlIOmPo1vCGl1yFzz1xDgCwMS5szMQY2ip91Y/VZuHMFgq2oxi3PnsNt73sGtz2smsAAH9779N489s/WctMm3osJzmYhAmU5K/VYHkQIEmzpsa0DagLe7lvacYYhMo0rLakMMVYufc9DgI/Dzr4iW96Ab5nXGCxoedPTz9M0xRnNkMcXx06vON6/PS3vQgbOxHedWfBXtLKwSTrIRdJp0Hfkg6mXa4UheL69Vz5tSwkcrBRlKjG03yMSzMPsUXAZGF7rSSRY9cUku++fN5ZFCt3H3PvfaVNWgSqWa3ZnoM+7C74C+gv1aHAfO+8Fgh1TI5HTmddxINcBCr8UGqYQI5ypEld7iRcUoXMRF27gXdgKPQEaQ9Jqo/2BrLPcPfj57A5jmqfxCw6d/sVeQGlSTmYb+4hizF0g5LFYvPoTtOf7NDmizgXJtB44ffR+05VviZ2jEXtIMfxlWIhbu4rbYIjUNDPJXInV+ku09380tPn8bH7T+/ZFJui5G9+8D6q6+4sBxMwEs1rNcg9XUbT57Ptkf7915n5lpFJRxUbI89rJR2sngnk5aa+TKEskzft/W42RjFGcZJ7ojWF4QQbXbsmHQiKQDNLB6s4x+0Pnq5lvdZBIhl1MZ4Gxqwvy3OQFUJdDIN1n38eMSlxXSvNPex3VGfPMe28Lo0rADi3tdtD7pMP7g0W0Ow9iuZ5jSTSsSEm2Xt02L/olsotoed7lRPi7Q+dBgBcOyVN56Cgl0th6hcNfYdFg9HpV8Glc2Qq/TYmkLbIFAQeQokpscN4/+CpTQDAW/74rqn/HiU6jwYpDi/18H2vknVM20Y+2VqMv1OHQly/J2EC6a+Bn3cH6xa22U9nDfyUxbn5XKzZaxkm5vz+Zy5UvsbVDLGDHGtTDEtdDahFnjcO0leziah7Dibx2l/+IOIk3bOhNwl47737KTx+VhYDDhSSTDUTSCCXM6/VIPcPq/CIM0wmTXpUHXujjDDRGSF7HndttYhq2FaDoDDvZq5xVXS12UQeWWq2CHT/Mxu7/p/1ojEwY8BOrb+du8dgP/Ar10WfephLZitDklKYpK5FoOaYQH7etFK9tbnEZGG7bJbNjhN9gbl++byu66GNCX+1H/z9O/a8RnOdbfepS1BJfo4KdmKHxUBXBGoJy4PqCPTz2xGW+wFedPXRlt/V/CDXtlo9e/S37GCKRKWMOE3VhrIiJpADi8N0T+u6za5Vf3MN7n3y/NR/b9ITCADu+qlvxL95g8w7oW2Y266uI5J7BKjp4XZJZDQDGUzdM+YqIzHoT/EEMud1KSR6noevf8FlFllnJwdrC2tTNokuxtBAdu3sKXz6Yqt5exqfg8kN/bGVAf79d70EALC5M51BOQ0ucqpAIGXInzWtMfQg+7sqc2gXplGfYAJpWRBtyMFs6WAGTOhB35/+3Zjr2bRsenPiemuNoQeCpthsmECedV2kgSSlcCbpYJbNdRjrikDmNlkkGc/k2qT8vdBMIEEBrnxe1/XQNFx5dHcKLpsAB9g9gVwsLgyWLUmRHfY3uiJQS6hL21jfGOHEIX4AWCTIkpHcXPoHAjmYdgNv3r9tc6o9/iDwkab2RYlL1d90dS9UbGZci3D7GWYzVbeoMtfGPSK+/hprnwFf4Lcyq3SwrGiZ7hrzwvEiznUjszLsCby9nE7RQYhJJpDvuSezSZhAUZKox9KcCaQoFExjvqwOMmvFuiSkSbjIqQLfszJdciaQsuBqil1Vnykab4w017o/HhtsG/eMear0BGqDCRRXj5XlMY5mAk0Z/83Y2SQTF+Du4TrIPYHcZcdpqivo1kEmB8t+ujR9bO97R+2LNV6vLBCDo67wzI5D2Rwjo0m5BMbU4YkJ5uixZX4PaE8Hc1/LLQ+CmY0LHeYPB3NHdxFg0jamYX1zpKbdLgrM4saWjOSyCKpLkgDcNo8SJpBLkaZvFlV1x3dgiQDI4+WrPIGi/5+99w6T5SrPfd9KHSbP7CxthR2UkTZGGWUhIUDmEOwDBlscgzCYcLDBYDg+NuZaj7n42tf3Xq45B7BJtsEcZAMimWiCIhLKOe29Je0cZmZP6O7pSueP6lVdXV2pa63qrur5fs/Dw+yZUXVNd9Wqtb71fu9rpetPHwbYXDWJR0DaIo0kSS1j0Ghzbl5PoKi5D28bCYPdD6/65K3u93R3N5t3Z0qOjK82rfSKPqI31o13GtWKWIvJMUoX27adgvoAlEAT1e7ntBuHHXFN+uFO14otkonxBAovAnGoWt1nZZwKoiDpYAHjmXc+11sRKLi9qV9KoJduWyPkOG47WEgRiLVO8yqBnp91Wtj//tadXMfxIycqAvGFKKgJEqp0w0qlrGwrRIanHyxobnLhlplUx+rdEyj7+cRUCr+vWCUQp0UEEC1gIIoPFYH6RKWkhJrU1Zqmu5u4WlHl+CIKd0R8TPoVVzpYQvlz6iJTkuNzVv0lOP9t2KNRRFRmUXGVQEnawTjVanHXELcxdAI1kwhPIADYdaTtMcHa3HgT5qIK6s7rpGsjIXpnoqLh3//gMpyxaULYMdUYpQu7BXk9gZK2DLFn0kVbZ/D+a0/t+rlrohxx3/rhKQLJiTyBONPBXGPo4PvMNNP787UVjzEx9wVOB3vLxSe7X/eywafJUmA7sO6OndmOa396/Zn4yR9dwX0cligX9iwTpTjd3Xq+/OKpw10/Gy0puPr09amO616jiTyB0j3PkrSDOel8vR+/osUr04tGUIvrF996AW7/yNU9H6vXdDBexdqHrjst9GcP/vnL8YsPXZXK78s1AA8zhhYwZ6/EzLeIYkNFoD4R1VfZMKzUvdfDAnvoRvuV8Ln0lwJ8SrxYVvpWhiRKHR4z00RKIEFtMEHrL9u2uYtwRYb92XHG0M7v8rXkRU3c+Axxo6XDzs/4WtoYQT4GugBPIMApqEdNStJGSxPpOGPTBM46TlwRSIlpk+BVqyXx+/AyX3NMea8/exPGyt2bNW7rVC9KoGZ6Y+VelEBpW1WyVAIlaf1mr5FmrJBzkA7mnc/14vUR1g7GPs+sx7WSKmPbujEhxwGAZogPpqjNhrbirft9qWhKl+9KUpL68wEcSiBZjlcCpfQEirt/i0hQi2u1pOD4qWrPx1KV5MbQIryrNkyEX4eTVQ0nrkkXCsTGg7DngUmeQEQMNFPuExVNDm2zaTTNVR0PD7QnDXdERD8bnAZtyZRA6Y8NZJcOlkRpxNsOxgh6DfaM4Y3KLCqSJDleHEnawTiKHEmUQKmjsd3Fb/jv8LaRMIImrmzCy2scXNUUNA0r8LOwbbu1eFyd1+mgWO9rC+NBjVG6cBeBErR6eJmrNQE4JtBBsF33up7cGLqhmyircqpiqyLLsZ43THWatpjrtrhFeAKlLUi4SZpJ4rFT7MDL8uDTwbxMh1w3QTjtYEHG0P3xBBJFKWbTKul7Fwcr8oyWu+fPPBsmagJ/Pn9keZrXiFUCGenuszSF6bwjam7CjpG0VY533QGEt8BPVPg6QKI29hq6iR89dhBPhAS9JIU8gYYbmin3ibKqwLKDdxbqupnKIHKYOO8kp7e3HlIoAxylDm+rTZxnT9rjM6+IhYYe+jtc6WAJfBS4pZ+t/zRo4sbet9XaDgY4RZQkCgU+JZASuTji8QTqxdeIf9ITUARylUD8RSAgOL6afT6lgiyWhoX3vewUYceKS7/iTeHrtQi03DLKHwuZsJe16NaXIAzLTl1ESWacbXO1XcYtInnGoZIS/yxjr5Gm6KEkSJcTgTtWxlyHrEiYBDVko0GPMKHOgs/9l/Pwsw9emfq/j9sUE6UE+sTrzwEAnLJ+PPA10j6L2wqLeNVs2r9BVeKNodMq7th6YpgUHKKSS9kxLDtZOIAIJVDQfbDjhCl87w8u4zouG3uCrqPDiytcx2aQJ9Bws7qNaPqI5pn4qL56T103V307WLWkYCSm4szb7qTFKoHSt4OxqOTZ5YgiEIc0U0uiBOKUfrL/MmgCzb63mr1W4lJ5RHkCrYRI6AG+Ql8iX6MIeX0vBCmBmoJ2s71GvCM+LzXXO4OUQH1F5PNLVaKTW3hbFt3kn4RqkTj/HjYmNntI4rFsG2mHarlVBLLtcAN03g0B1+cooh0s/eK3pbKIKZrplo2RFPex3K90sIQJbL3MKcI2GgxByYpJedkZG7j+e3ZPhLU2t987vr9nckTDaMi80eJ6VsbbE7DPJO2cK4kaxbLTHT8u3a+I8La4evE+A2REH8+wbFQ0vtf0J+6+8/Kt+G+vOoPrmIAz1slS9Jydl4oW7mdLFB+aKfcJtii6+d4Xun5G7WAOcYavvP2tjhIoOnUm7bx5oqJBloDZ5fDqu81h3JwsfSy7ncIoE8zVQlyihAgVTTmuHcxOv8PP5ttJIuJ5L6MgJY6bcMN5DVXU8Amu6zu0ihVrRSdWCcS5A8+KR4/sPZbo9xsxRaCy0rsSiKd1l/3dUXN8g9O/La4djMefL7EnkGml+huUfqeDCRxr5BAlkFGwcU2SpMhnmcj3rlpSUAtQKnB5MMZ4rQDtlM20mxpJjKHTFrIqQ9gOxtvi6kVxPZ/ixwnesRRA1/Up4m9gqCEeenHja1KqJXmoFGVEJ6t3Rddn2CL+o7c82vF907Kx1DQwFtDTvNqoaArqzeCBy7adSFHeIlCk6S7HxFyWJYxXNCw1wtvZmqaVfsLg7jZnkz4GAP/XbzJpdbcxJJvMreY2G1mK9ppI2h4QRZJrNHU7WOu8ohZItRUDFU3mjlgPuo9E+VpUIqTu7DXSmGkSfPz5q8/E//PGHdzHiWt34lUCnbHRaR05lFAuz55JYS3bbRPcHopAHAV7NxEmQkVgWFasQiWKuHYePWWBBkjuCZR28dW3dLAMWrTUEBUTW9AVyfA+6lkmUtUxVla7lBaAU6RJXWh1g0qi7zGA7zXi2sHSqt/LCYJEigaPGb0fNcEY2vm6fPfd71x4En79nE249Y+vwvVnb8I7LtvKdTwvYeOdKBVYRSVPoGGG2sH6RNji+Vhdh20D0z0kSAwr1VK4Cz2bF3EVgZQ4TyC+CV01RjbZaJoYSen95O7+xkSW8uwwnLRmFNefvQlPHuw2knN3w0urd8hwevjj21R4lUBRRSAek8Ik7WBzNR1rRvlNfoOKSCxul3ch0/YrCfKuEtPORvTOWy/ZIuQ4celgFqcn0PqJCiqajJWEE9u4drAkKk0/PK3NSTyNeNq1AG+Me3j0cNpibkmNN90F0ptP9z8dTNxYI4cs6FxT3AJtwpQj0lhNgQW06dES5pab3a9h21zJXUB0RDy3J5AsRxaZ2GukmfMylV4/iqH9QkTcOYPdR0neH9NKX/BmTI5o+Ls3vwQA8KnffgnXsfyEKcpEtXAxY+io9mOiuNBMuU+E7UzPth5evcSIDisVTcYvdwWng7GJP89YHJe8xOPTADjnH1Uxr+vp2/7au7/RiyPenbWw9+iZw0sAwhdCqwFZkvDdh/aHSqwtIZ5ASmQRiMccPYkx9FytielRLdXxO17Lc4rPtq4d5gHC6yvFrsEv3bkb335wX8fP2jvmNFkpKkmVQFztTjGtx16+/8gBAEA5xOBXafky9KoESjuhVhMUgUwO42agnYYYVvTm2R13W22yiojvUzqYCA84P2Gm1q7XWYGK21FprOy6ElHUmhkpuQl+Xkwr/XxIS6AE4t30UWPaXgGkVr8n8TQqGian2b0XNcF8mpF2HOoXSoiHnjAlkKbAtsP9vYhiU5wnSsGRQszHWJrURIV/4VV0FhsGjix1P8yBtv8Bj9JFU6RIeSxvu1klZmHBYwCe1NSXNyK+osmB/fVv/cI9AJz+4NXKkaUVzNV0fOLfHw/8ucE5KQSiJ87Oa6TflXIVBBELpGN1HZNVEUWg9jm+58v3AfBM/Dkncuwa/Nd79+C//sv9HerBIrZNEJ0k9QTieRb0knjy48cPAkDkfVGKUD0EYXG07iZXAvHdA1GeJYZppS609tYO1vvf0K90MLe9NeSDvGDLDHZsnuzpmGGtHa6fWo4Xo36iNt1EpVACwUogi3OMUN1CZXYegEki4tP6GiVpGS0ahskf1c5QEsynGSLSwbIkrJi4HNAimYbRVveCqOMR+YJmyn0iqGcZaO8elsnDAq/7teMBBLc8sZ09nhpHSVFgWnbowM+bPhbVzgY4Jn1pi0CJlEBWW+2RlumREuZrTdghhYLVbAzNOLwU7CUiJCJek9GMSQdLO7Flu6JRE59600RVE9Dy5znFJw447YW6oIWM/x7yFi2L2DZBdOIogcIXL00Baq9KTBIlgxWKPnTdaSj7Yz09xBVv/fCoNpPsYpscbaMMTQkPUuDx59ASRsTrKQtNckyKoyhcn7yQudvX3nkxbnnvpT0dM7QI5CpnivP8LatKaNKlO04LWFzPjJYw61MCmZwto+y89Kj2b5vvb4hrewXSq9N7UboUhaZpCfP660kJZPJ7AmVJWGDJbECLZBqYVclcLTz5mCgu+b2yh4ywKmrcRGI14U4OAx687XYwPtNdINy7gVdJE7e73OBoB2u3AES3s/FO/GdGSzAsO7RoSSkB6IolZ7CPhssTSInzBEq/K8XO65lDS6G/09DNUAPcXgg0hhYUc+y/hxbq7ckJKYGKT1wKH/tZieMzdvzb4scytrhcE9Ou3bMSiKMdTJbji7m8nkAAM64NaefhSMxhn1tcRHzaNox+KYGaGZjQK6HG0CxZsTjF7WRKIP73bmpEQ0O3OuZevGpBrQclUPrXSBARn7LYmkQtWDSahs015ntxN1UTjNn5VwIFFxODfLLSMOMWgcQcj8gXNFPuE1vWjrpfe1UWtGhpE9XHzMY4Hs8bLSZhy7b5Wgzi2sEauoVKiK9EHErEe8Mwbf52sKmR1oC/HFz13zRZ4Tp+kbng5BkAwFRIW0i73YlXCZRNOhhT0Hzxjt24//m5wN9xfKv4x6Ljp7qvE9e0mdcTyFekevs//qrrNYrUNkF0oirRi3jXH4XjmRk3VjPYRDouuKFXJZBt26lVm4k8gQT4WKhyuBKIx59Dc42ho98vJ4EshTF0n9LB2omZYotAQXUBQ8A132+iCqNClUAj3YtUi1ul4/h8RV2jhsn3GqosuwbZYVhpPYESFLGKhlAlEPN8SugJxJO0mDVqiCfQfGtzjPcWm3bXBFQEGkaK80QpOC8/ayNe8+LjAHRO3kgJ1CbqwSWiHawcE+XL2w4Wlz7GY6aZJM3AEuAJNNMyBfbLqy/aOoOZ0RLO2TzFdfwi8+kbzgUAjIf4d7lqNU5PoLiI+LSTztFyW8HEWrT88JiXe9m+fhzrxztTxkQVvP3n51U2GVRULzxxbRIi2sFKigzdiF8AJA1uUBQpMrnRj8VRsE/iZyEi1lhTpNCdcsOyUheZevEESvMZK5KEPnSDZaMEkoLVIUVsc40qjLJFqyhPIKCz/UWE51BFiw5p4DUGVxUpst0M4EgHG0JPoKZhCiu4JvHYZIhIB8uSMA89Nnbf92fXch2frZvIGHo4oZlyHzlt4ziAzupzFhOJouLG0gY8uOzWt3iKHO7kM7IIxNduFpc+lj6yNIEPhIB2sLCqf0O3cNZxE1zHLjozoyVoihTqc8DWNDxqtbKmxBhDp/cE8hI2+eHxrfJzskf9CPDvnDKizq/pmrXSeFpU4tLBRLSDlVQZKwlaAZi6gI2LYTiL9+SVB5MjhID92XHm2WLawcI9gbjbwRJExKdRvshytPm9KPQMlECOnxG6PPnY56AVaFyLmg+JehYAwe0qloD5Ylx7v4h0sLgihJ1yYzKJh2TR0E1b2DopibKeweN/1g/CriPDsrF2rOSq+9MSZ6NBFJviPFGGAK+M+6t3P48X/fkPsKKLn0gUFTbQ/uMdu7t+JioiHgguAtm2zeXTwI4fNbHNevfXsvilnzMBu2qA4xUjqjhQZMoREe4idh8dJVD4xNMS1J8eZJxqWjZWDEvY5+xVAtm23VYCcU7kokz0i5iiQ3SiyFLkhFNEO1hcwZ7BxsHpkejEvDAvlzB4VKfJlUB898ALs3V84/69wcfnMEttG0NHJXXa0E07lQeO3GdPIN7xzAsb2/2n324HK864VlLDVa0ikjQZrEDboQTiVOkA8S2jIopAummHhnAA6Tf23LXGMLWDGekTCf0kaall5N0TKEw5y2Md4CVu85woNlR56CNs0mRYNv7kGw9jacXAfN15cJESqL2A++R/PNP1M1NAq81Eq41nodHtd8Oew3yeQ/GtPGmLQEmUQLxKJsDjCeRrB9MF9mMXmbIaXqQRUQQqqzIsO9iw0LZtIW0eQPAOGDNYFhERDwAff/3Zrhda07SE7WZLkoRPvfkleOflWwEAp20Yd38mynyaGBzlmAKNsHawBDubjdYmTZxZehJ/Dy82x1idzBNIXAtDkBrC4Di+q/iNeP/Z35am0Kcpcl/aYHQBijQ/YdHeukDlTL+Iuo8XW3OwsNbqXhgtO/emSGNowLnnExWB0t7HSoKNvZQbk8OoBBLpCaREdB34ETXnyoooJZAIRTQpgYab/F7ZQ4h38sbu2YW6k8JESqDoQUZEOtg087sJMDgToTRyJj3RKo60BYJ22kM2psGMiYoKRZa6ikB53w3pFyVVdtV7ftq7j3zHB4L9MkSYo7ePFZAmwVpfRsUUgSYqGm646CQAQKNpue0TInazrz9nE/7bq87AtWdu6PAJaxrF884gOqnG7MC31V7ZK4GMhO2FcogvQxiOapPvWRBV6HCUOmLugaBUmLTJXUBbORPX9gqku48dL6PsF79sw0ek6pBdE/6P1rAsKLLEpVTuN1FKoNlW8ISIZ01ZdYpA3mcme77xPCurmoJGRDtY29yaM+wj1uex92NLkgRVjk8fKxJNw0JJFaNS7kUJZJjF9AQSpQQqkSfQUEOVhz7CbkhvMs+x1u67SElxUfEOyH/yjYfd3SKgrdThKgIFyIYZ7KW5TH1j2sF4PHvYQ+j//fHTob9j2fx+MZIkYbKq4VM/fRYvzNbc7+e9L7pflCMmtparBOJbnAIILDS56WMCFh1Bk5+k/ie9wBQUNd2ALjARhqEpna1D7D2ionpxiduBF2EwrilSoiIQu2bjFvqqLAUWVsMwbTt1yAFb2GadDsYIel7ybAok8QRyP+MUY6mmhKdSieQnjx+EJPG1kPtxF6d+TyCzeJsw5Yh0MJHPmnLAM7Otyk1/3IomR45D7vM+tUF6MnU3z8bhUCmBDAslYe1gydLTrNaGfZ7nvo4SKNhMXsSYUUpo5E8UE5op9xF2Q37yJ+2F/JGlFUhSd+LNasT7wPrKL5/HZ36+0/23CKXOWCsdqRawuyMifUxTpMiBUsTu7/5jjfDjc5iNemGT/g//20Pu90gJ5OB4AgVPDF2fAx5j6IBdTQZ7zouYkAT5l7D7wpsixgu755YahrujJnbR1NkPL8IvhhgsVU1BI1ERiNPEP8Gk1jCTKTB6VQLZPIu7BEmRIloYXr3DSTOdr3W3TxumnfoeS+IJ5BoHp1ICJWv142XFsIQbNbNNHH9roW7ahWtxjUoHW14xoMqSEP+5tlIhoB2M41kT5wnE+7x3E6qiNg45LQSGyRNouWlgpCRmbpIkbRdoz5PyPPdV5GDlo9lSD/LijtcJ0jSJ4lGsp0rBYTfk4orhfm/fsQamqlquK839wj9x83r3uEodjod6O4I+qNWGyJlAzwAAIABJREFUf9JQUhSYlh36YDG50sHa/2FYFLFp2RDZBeN9L/LeF90vylq4EqjtQ5D++ImUQALGiqDJuZGBUservjMs8QsZ1df6UUTvDKKTiqagoVuh45wuoB1MU2S3PTGKpLupqtxrRHz6Z00yTyD+ov37rt4OAJgNbAdL3yLhFNWii0C6lb6Y2692sPlaE79x7mahx2TP7y4lkGUVrsW1FOOfJ+rvUWUJstTZrmIJMIaOSwfjfQ01gS+NzTNOKMGGwUVlbrnpBpfwkqSlFuDzJusXYSmOolqCFVmCIktomuH3AlFc8ntlDyFs0PdOUPbP14W2XxQZ/8RtyVMsYxNsHhEBe/9vvncPnjm02PEzEX4rcQZqTpGGb/cXCJdlimgH8+LdpSMlkEM5whPIcneN0g+rZdcTqPuBK2J3kxG0w2ma/Ofvh3k+zNWa0E3xCxlVlrB3vu4Wdt34cGqvLSyshTCs2CqiHSxpRLyRUIGh9Oi/wZUOJsW3kYho351m0dsB7WC8C4y4li3X9ynFa/RDCWTbNuZqOmYE+acxlJAC3/3PzwvxgusnZVUJVQLpphjTWsBpx/OndooIaaiWohWJ7BpN3+IfbwxtcowTw+QJpJsWFhqGsLVSUk+gLDbGRGNaNu59bi7w+6LmW7LkjEHE8EEz5T4SFO16aHHFnWytdl5+1oaOf3sfwCJ2dph0+9F9C3jHP97b8TO2AOYpolQ05/hB7Wa2226W7vgVz6I2tAjEIR0OfE2t/ZqsLWK1k6gdTIASqBFQaGrvSqX/HN52yRbn+IGJP+JiexksaWy+pkM3LeFKoJ88fggA8OmfPwvA0w5G12phGW0VgbybAF5EtINVWgvUIFWol6QKDEWSusx8o0ib+gO0788o5ZGIdDDvveuHV9VXUuTI9oJ2O1hKT6CMTUwXGgZMyxa+geeqlX0X0775eoeCvAiUIpIuRbWqMMqajJWA+SLPfCjOoJ75sPAUaYD4QBQeT6AkxsdFgI1Booquivvex7SDcRb6+sFdO2cBAHfvmu34vkj1vm7aOLAQbkVBFBcqAvWRdsx356BPSiCHczZP4Yfvv9z9t1cRLaYdrP3f7jyy3PEz9rDn8WaaDolXB/h3plRFxkd//UwACG1jMO30SqMgqqQE6iLKGJp9LiUl/TVUjkgHE7G7+dFXn4lNk5VgJZCAIpMf1sPf0M1MzE3Z37HriGNiTp5AxYdtiswHjKOAp+WP4zNmbQUsmCGMpIoFR5LfgxIoZeoPey0geyWQpsjQFAmNgKI3b/KM39DdD2uRSVPo00LaI0TC1FGi2lMYYf4bSyuGm7RYFKKSLnXLFpqq5n8us5fkuUYrMe1gpm1zedwFdQb4saz0xWI1xCumiLSTS0UpgeJVWIDYMI6s8T/LRM7ZX/mijcj/O0CkgWbKfYQ9kPy7/KIlxUXGWxDrLAIJaAeLGBDdIlAp/S0RJZ83RfSol8JNgwFn4iOyHeypQ0vubrNh2alTMIaJKE8gV6Gg8rcUBu1ks9flLfQ5O5zhnkMid71YIbGuW5mYm45XnCLTwdYuFSsQUDpYcYlKcQTa9xnPZ+yO1SGFJoZhWokWq7LU2647zw4/2wjJ2hMICF8I87Z2aoocG3EPpGtN7Uc72KzgRSkjqHBSb5pYMSysGSvWZqGbKhTwLDMF+ZUw/O1ghqvS4W0Hi7hGLb72+0QR8Tw+koo8NEqgA61AlBlR7WBuIT2ZJ1CelUBhGALVdiV1uPyliDY0U+4j7Hb0V2xJCdRmaqRdELPRHnRsAfLeqB2VhhAlEPM/6d5dZs8aPuPpaJd+m6N/3MvWdaMAgAdfmMff/fQZAKQEYlTU8N3BditS+mG14hZNul/jb374JABgPka9EEc5ZGHnKoGETs6d96KumzCsZAvqXmBFpdueOQKg3XpQhJ07IpgoRSXQVtzxfMZRY7UXI6GvgipLgYl7YVi2zbHDz1qGotupRLQChCW18T4PNCW8mA54FX29v4aqyNBN250zZAFTqU1VxW7gsQhsb+Fkzn2tYs0TozY0HMN1ccuPss+EWkSSZkVV0DSt0EKKxXkPuPO5iIKl4wmUXgmkD8nC/ZYH9gEANk5WhBxvmDyBwuDxIPWjyvLQqMqITqgI1EeWm+2e7k2ewYw8gdp4lQLe8dkUUESJgi26eSJLWetLYKuNqwRKfXhoEabB7DVEVP5vec8l7tc/f+owbNumdLAWkyMaFkKKME0BKhS2qDgWsDj9jycc/xu2K5aWkhq8U56FJ5AsS6hocrsdTLBCh03iWPFWL/CkjXBgLTazy8H3mYjPmF0vYSbv7muZyWLAw2J6w3DSwRL/egftNpKIxaOgon211O2LIuJ5UFKjFxVsLEpTNC4laJfjhfn+jZXFRFYzgpRA7LVGy/xx6v2k7Ea3B6tORRbqHU8gTzuYgPlWXNCHwbnIZnPNsGKobdtc6WCOJ9BwGEM3W4rMrevGhBwviQoL8CqB8j/39X/WSTcwkhDXvksUl/xf2UPEYqNdBLpwy4z7tSiJ47AR1A6W1dqOGeXyKIFYu1aQ6a6IZKe2vDo8Il5EkWy8ouHS7WsBOO87e07Swtq5VxdXjMDdTRHtYFEqiNFWkbHW5DMILYcYp7aVQGIfCyxqt2nym9X6Ye1fbNKvtyaLaVUWxOCZGmknygWhmxZKisz1GZdVtgCLjr11CpcJjKFlyX1GJYHHxJ8VRqJ2+UW17wbFZLNxIk1yF0OVoxcVrMCVZvGlJVBY8MLahHg2jYIIOncRKuVBUIosAoltByspfk8gAfOtiPNnr8Fzj7mq3xBlMa8PZq+F6Twzt9zE2cdPCjteck+g4mwq+VsXeX3bvITF0BPFh4pAfcS7uNrgUQJ5W6AIYMNEGQA6JtVuESijwViEEohN0v743x7q+pklQGXBdtbuePZI4M9tW5yKY/N0FYAzAcnCK6aoTLbu1dsDPgPWpsLjezNR1SBLwb5S68ad+4IpztJSUoPjmbNQAgHtlBUjg3SwjZPOe8JaPwzTEl7EIvpLRVMwWlIC7wHAuc94dzjjFngAcMsDe/H9Rw8gSW3HiYjvjyeQ2w4WqQQSU3B97mgNP3zsIHZ5ghTccYLTEyjSGJojIl51CynZLVpEzBeCCPLRaWT0WlnD5it37Tza9TMjocIu+Wt1pnaKSJONamcD+NV2LH01LIZ+15ElAJ22CL2gDZEn0FytKdQ2w1UCxRSKzQLNff/wfz3Q8W/DFNsORkqg4YRmy33kDedtdr9+8wUnul+/tKW6IBy+8W6nHck76NicuyJxtBNn+FsMghARWXp+Sz0WFp1sciTO+PnTVhLZjs1ThTbHE825J00DAPbPd7dkiWhTUWQJUyMl13jUyzVnbAAAfPC601IfHwiX9poZxatXSo6viCE4EQYAPv9fzsfasbKr7HDMp+k6LTph9wDAH08OeFtVwpVAN33nMQDJPLgUWYqMbPfDExGfJFXIEGS8y4odP3z0QPvYrhIo/WegqXJkkaadVNj7a7B2sEyVQEw5XBKsBAoyhtazea2secmJzrMyaL4iUqUAdAc2uHMWLuV19HXEq7xmn2dYDP2euToAYFvKFihliDyB6rqJisDrv53UXHwl0L+962L3a68Pmm5abiGTF00ZHlUZ0QkVgfqId0Jz0ppR92vRfeVF57ipKi7aOtPxUM+6HUxEK0w5YsA1BSiZxsoqyqocOmkwbb60Cv9rrR0roWGYhXgQ9ovNUyMAgiduItpUAMe0di7AD4VdQ6Ock6GSGtwOJmKHPwhmLuskCol95KyfqOCN529GXTdh23arHYwea0VnZrQUqgRqCviMy61d+DhPIABYDim6e+lVCcRj4u+2DEWlawk28vfet6bJvymgxbSD6RzRzP1oB3OVQIIWWYwgJVBdQKv6IGCq2SA1iugNgbLa6QnECrI886E4JRDvPVaNaQdj79uJMyOpjq8OkSeQYdpc7ad+2LgS2w4mYKzLmrOOa7fJeeelIudCakyaI1FcaLZM5BJ/5Cdvf3QQXimoCCPBqAmHm1bBG+9dUgI9hwBnYSFK/gk48vNG0xTSyjYsVErOBbLz8BI+9q1HO64h3RCTfjUzWgqMx2YtHrxFJk1x2sH++a7n8Nc/eMJz/GyKfawdLCuVTlVTYFo2dNN2JotUBCo80yH3ACDmPmt7AoVPbI8sOa9fCxlvvTgLrl6NodOn/gDRSiBTsJG/9/02OAo07eNFtxcYZnq1EStYZblzXddNlBRZeFG7HGBGnFXrWdawz65pWPir7z+Bpw4uuj8TpVRjlFtJXgxTQDtYXDHR4vQEqkYkgQL88eTD5AlkCN5ASpKw6P15ntNGvZvP3mdm0xCoBJKlzBMXs8K0bPzFtx/DnrnaoE8ll9Bsuc98/HVn46bXnDXo08g9zs5O++HYNooUNxg3jICdo4zazUQUmYD2gjrwNQQZQ3tfq2GY7k4YLa6dnVpZAr78y+fxxTt2477n592f6ablyvl5mBopBZriijLTZEqgP/3mI/jUT5/tOD4gvthXaZnLZuXXU/FMph21UX4nbEQyJioqFkMUOE0BMvck7WC9oPRYBOJp3WX3UGQRRZAnkP81nWPzq2bj28HSP+9ZwSrI90wU9abperqIRA0oPDQK2g4myxJkyUmz/J8/exZv/cI97s+cdDBx719FkzsUNSJa2JkqK6xQzJsOFqc04rUQ0BR5aMx8dcHKMXZdxI3Z7XEov3Nf76bgvCdVVsRzksHu1SJ6TD3wwjw+f/su/NHXHhz0qeSS/F7ZQ8qbLzwRN1x88qBPI/eUNaXj4cgexFEtV73inTSImNgCwPuu3g5JQlfFXFSRySkCdU8aLMtJ8RK5AK6WnMU7KzqNFGwSmgWSJHXI8r0P2aYgFcrMSIgSyBTT4lHqczpYpXXN6hmpdNxUPt1sTRbpsVZ0mAoxiHrT5G6NcYtAIe1gcYahftIUgdLeZ64nUMjrsWeByGKu2qEE4lcMxrWD8UXEZ68EauhmJkUZ1V2ctr9X1HYwwFk8Hl1eAdCZamkIepYx2IYVwzWG5phvBfkzeTE5zN2B+IU1e9m0c7peW1TzjOgNpCRqSu/PRbaiZUmXEkhYO1gyD6U84oaGFPDc+wHNlolcUlZl7DyyjO8/sh9Ae7dEVGUb6ExlaPeQ8x2zUlJg204rwU8eP+h+X5S5ckmV8e0H93UVmZjSSOTEqtJSHdULGlGbFd7J/87DS+7XzBOIl+lRRwnk/4xFKoEWGu0dI/9DUvR8p1pS8Pj+BRiWmHa5ruO3rsudh5fx3Yf2kXfVEFDVFNR0E1/71Qv43sP73e8vNHT88LGD3DuSbAH2r/ftCTR0bkS0iQUeT5bdMTgJhmWlbiVpG0OHL06dcxKpBPIUgczs28F4npdBahrR1HX+QmQQslsE8raDOV8X8fmryRJ++uRhAMBcTe941ogsUlZaG1YM9tFzpbGy6ygsHYyzpY3dU2HeXqztkqdtdJg8gURucMqyBElCrM9N0UJRvApykUogLYH6lCgmVAQaIBecPIPTN44P+jRyCdvB+f1/vg+6abmyfeblIAJvaoWIHnIAGG3Fd7/nK/fhxi/9Cs8frQk9/hMHnL76Wx7Y1/H99sNK3C3NVEdsciUynaHIeL0ZPuCRmDpGfPyThcmqBt20u7xITMsWIqHXFBkNjwKCtWWw8+f1HPLDjvb0oSXhHhpA+/N409/fBctGT4txIp9USwrmazr++F8fwru/fJ/bz/+1e14A4FxLInjuaA1fbR3TS5hZaxiyJLmGyUngiZfWYvws3GeBgLHoNS8+DkA7ndP7ulx+K6ocm24GpFMl9q8dLDslkPezZZswIlXQ/UL1xZR/5yGnoGsKVmxWNcdDkhV0TXdDIzsl0Iphci2y3ZakkPuAN+Z+mDyBdEt84IMmx7fLFcETCGiPeVkpgdwxtcfNkTwQ1XZMUBFooHzt9y/G9//w8kGfRi7x+t7UddNtBxOpBPJWzUX5oUy1EjEe3XsMAHCkJYXmmdQG4feMySLBq9pqySAlUCdh74OoNIYRT3uTF5FKoM7jOvdWVgub3zh3MwBnIZmFrNryFX3++6vOEP4aRH/xX4fsI44yck7LwYVG1/f8914cqtJb6wXPvcy8VsIWeCIi3Bkfuu601jG747d5xjpNliKLNDyFrH60g9Uzagdj14RXndbQHf8hUcmf/cS/KXJkyZkP6aYlVgnUGi9YSxhvAQVoX0dh6oe5mo7pkVLq48fFlLvtYCn/hl7HpDwjun0QSNbCm8XmahY8cdMrIUlwEzXNVkuwqMKZ23JfwCJQr8/y1Ua+r2xi1eLtH2802+bEInfD9s23J/9uAhanCmJm1JkULLd2klm8sC5AQu/Fr6gQEdvrp1py2sEaVATqIGzy3zTE7G6GpYaYliUk/c2/O8R2ShoZtTjMeCbKWeyo+VUb5AlUfPzX4f5jjcySSYJuqTDz/TBkSepJgcajBAKc8T+sjUTks6CdkNT+29izjDd5KYknUJr3KOt2MNu28eSBxUzGyqDCwL75urAd/X4TtullCjb69cettxfv6Y8ZZ9w8V2u68700SJLU8u0JuY9ZO1jaIpAsF9LI149t2zAEqaC9qAmUUllsrmaBIkuYrGp4spXAJ9o+o+K7v4pEr8/y1UYxnyzE0LNt3Zj7tVcJxFsE2rJ21P36Ww+2W6pE9f5umqx0/Huh7hSBeIwug/ArKkTE9vqpaApqTcNtSypaOklWhKllRKWDVfqtBGotlrIyO50e1dyvsyjQbJ4e6fh33idsRDxVX/LSGz5zJ750x243MfKEmaqw1wqq3fQ62e01It7gjHDXIhYwIp8FbQPVbiUQlzG0Gr0Ay3M62J3PHsWhxZVMfELankDt9+ZnTx5GUdfy/muQtSHzXv9+/BsnvMlaQPtZFaY+nK/pmKpqgT9Lihph3uz6GnF4AsV53hSBtrJRsBJIifdM4hmH+s18TccPHj2Ipw4ueuwzBCmBtOA5aRFg65cixtv3AyoCEbnkD685FW+7ZAsA58HeVgLxLVK/9d5LcMdHrsZYWe0YIEUVgbav7/R4Ym1brpmmoIlPlxIoAwO76RENx+o65lqxk6zVbbXjLQKduWnC/doxhuZ//9sP3M4JiuMJJF4JxCZZWZmdendLsygCXbxtDc4+ftL9dxEmbEQ00wE77D96/KC7yPvu+y4T9lpBC6Ve2yhYa0HSiaYIJVCoMbTAZwF7znjfD6YK4tmZV2U5skjDswPPxphePJp6Yc9cHQDwRy8/Tfixg5RA1ZKCF58wJfy1+gH7LHZsdsbneTYfsiyxIRa+jRM2X+R53rD5YZiniC7AeDdKjcLrI6nIvfmU5RVDwHgThCpL0JN6AhVoTrF3vu5GxU9yFikZ1ZCNySIwX+tO2iXaUBGIyCXVkoLLTlkLwNmVFeUJNF7RcNxUFdvWjXbIfEUZN/thPbrtibMgJZDiVwKJf1jNjJagmzb2zDqmrDz978OEV6XgXcjogmJMw9rBRCmB/NcOa5uo6xbKGRSBqpriTqizmkxduGXG/TrvJo5EPEFjTb3lTzYzWsJERVxBOqjdo9c2CtfLJeF/ZnB6omhK+AJG5LOAjRXehbAIJVBJzS4dTHELKdmoIGZbi4pT1o/F/GbvKAFKIMO0OhTMRYJdI2ceN4FNkxXXuNbMICIeAOpN5zNnz2UeJQQrIIW1g4lQM0X50picbZdqxBhRJFjbq+hk0SRFsqKlgwFOOA0bo3jaFb1UQuakRYBtxJNBdDDqoE+AIMKoeBQRontc/ZNQEWkSQcx6dr4AcUogP1kY2LFdhM/8YifKqkxeKy28ahlv20jTtFEtCSgCtY7RlQ5m2mI8gXxqOsO0YVk2fvHUYVzgKaaIQpIkTI+UcGChkUk6GABMeHa88m7iSMQTNHl1kgotVASnJAUt8rwFhCQLSe/iPcmCgVsJJCdRAolJEgQ628HazzK+IlZkOphbaEqfDpaFKe4Hb34Q37x/L0qq7Br4i4T9vd7CQNMQF/Xcb9h4r8oypkdKuPnePbj9mSPQBalaGf6Nk//+jUcA8M0X255AwQtf3nsYiPbGYrdH+naw4fAEMjLwuwRaY2jM+6Nn9NpZYtu2qwQSpd5n95d/TloEZped98IfpkM4FPPJQqwKvBLEFcOEKkvCBmNNkTuVQAJ3T7/5nkvcr5l80hCkBPrnGy/sOB4jCyXQpS0lFgCsHSsLO27R8frmeP0CdENMOxgrvi3U9Y7vrxhi0ru6VWQW5luvtXlanNeKF9beI+L9CeKcze12sCJJt4lggrypGroJwxK3IL759y8G4BRv/bDnwTsu34ofvj8+wTNIwRGFYdlcEe5qRBFF5LNAbSWRecc5Ec8ytgCzwlQQXEqg7NLB7tp5FNvWjeETrz8bkuANIwBgf66//a6oGzDjFWefWZEljJade3rfsYYw1SyDbZz4lQpcCXYBKjiGbduJC75RRCmB2L2R9m1yIuKL7wm02HDmJiLVn4AzfsV5ArH3rwj331/9xtkAHBUcU8SNlMToPCpatCouz7BujCK2svWD/F/ZxKrFu7vTNCyhyWAltdOTQKTs09u/3zSc47LdHt7Y3pPXOia4/olDFgZ2Gycq7nt++anrhB236HgLMbqvHUzEZGGq1Qrj37kQ5dnDFtHsWtFN25XpX5HR5zxZdSYjWSmBtq5tt2YUadeOCCYoDaneNIW1RALA+SfP4PipaogSyBlfX/mijThpTXwrTtvLJdkkmVdFoClyaKuHyGeBJEmoakrH4lqE0oiNQWEJZ26hKU06mDuuiV+wzC03cekpa/H6l2wWfmygnRjFCgC2baMpwHtmULBkSE2ROvwcl1eMbCLifQs9IUqggOtI1KahpoSrUXjUcM5/15tZfV5hcxNRrU0MJcKUm8HG2CIUgU7f6PhTNg2rvd4QtOnG7t0wk/Q8w7oxiljA6gf5v7KJVYs39lP0RKjkUwJZtg1JgvDdPTaBcCcNnIOyG9nrmzxnoQSSJMl98FI8fBvve3GsruNTP30GgMAiUEsJxCY/jIZuuQaYPDDvWtbOYJi2W3DKyvdpvLWLl5VfT8XThkdKoOITNNbXdbPlJZLdZgDDNHtbgLmeQAnmmSzymKeIokbs8ot+Fiw3TXzutl3uv9kCg7cdDAhX65iWBUlKF4/NxhjeBbBp2fjIvz2Et37hbrz1C3fjd79wN5abJqYzDkjwLk5FeNsMEpYMqZt2xz2tZ+QJ5C8CcflWtZ7lP33iUNfP2OfDo+YDotU6bsJZWiXQkHgCuXMTwUWgJEUyndlQFKAI5K4NTG8RSMx5s/FnJaQ1Ms8wJVBWaZFFJ/9XNrFqYRLEum5iRbe4k8G8aL7JvyGgv9vL375hB4D2Q6S9o8D3Gu3IXl87WEa9y2NlR8EhwutmWPBfh3/9gycBiJPtq4qMyarmPrwYDd3sis5Ow3knT+OS7Wvwe5dtBeA82JdWDADAWCUbmzg2SedVwsUdHyAl0DAQdB+NlBShSiDAmdzrEUqgpK/VixkxW3fwpoOFGV1m9Sxg6hQRGxqsuBam1uF5HrvH5lwA752r46v3vIBnDi/h6HITs8tNvOTEKVx2SraqWGdx2po3mGLmDYNi06TTXvzkgcWuQpZIVWg5pAjEs6nH/tuga1SUEkhVoiLiW/dxyr9BGxJPoMWGMzcZFzw3UeTwMZThFrwLcP+V3EKN5Rk3RBWBWkogvXiFFDKGjoaMoYnc4o39FK0EKvsM+SzLFmoK/fqXbMbnb9/lFppERcSrSvDkWZTSyA97TyoCC3BFJ+w6dCJjxbz/M6MlzNY6PYFEtYNtnh7Bl99+Ee7ZPQv8yGe8ntGOF7sus1rMeFv0sjJfJ/pH0D2mmzZMyxI6xmmqFN3ukfC1XE+gBBHxhoB2LU2RQgtOWT0LdMtCWVa421QAZxMGCN+d5fFbYQtzk3Pnl7URfOzVZ+FlZ2zgOlYvKJJHCVQgJUIQV5y6Dn/7o6ewuKJjw0Snr6DITTf2/jRNG3aCezAprzhrI3YdWe76frtInGFEPKdFAfMbsm07E/+qfsEKe6LV6N5iaxiGJbaYkiUld21gi28H09oFpiJhWTbmWvNo0xLj4zVs5P/KJlYtbNC///l5rBim2HYwtbMd7OG9xyBw7gCgM/lBlDE0G9T/vx8/jV88ddj9PvtadDISW2gEGbWuVsIerKLawQBgekTD7PIKvvfwfuimBcuy8dzRmtDPgd1fX79vDx7aMw9AXPqeHzbhz8oTyPu+Uw2o+ATdY0eWVvDc0ZpwJdA9u2e7vt9roYbt1ifZeRehIohaPIpaoPphz0sR6WClmHYwRwmU0gtFUDpYVm0ocShK2xOonYpazOcvU28sNowuBa3IIqVbBDIsoQvViiZj37F6x1wLEKcEUiISqkzLhsxhUeAWQwuuBmIJrMKLQBEqLAa7/4qgxGun2XnawUSlKSvFbAdbbBgwLRtrx5wxPAufuKJD02Uit7CF3fOzNeHG0BVN6Yj3PnCsIbxntKTI7oSk0Ro8eVva2HuyuGLgLZ+/G7bt7PT83z96CoB4PxQmoRSVMjAMhF2HIlNcJqsabn/mKN795fvwudt24alDiwAgtFDJ2i2/fv9efOqnzwLIbsdZgnNd9mMXhpRAxcd7HVY8LZA7jywLHeNqTROLDaPLNLLXRZ7bDpZAct5rq1kQalS0dAb+cICnCCSg3UxToneWeXZsNc+OOA+sHXcmI5+0MFSPJxAz5K4IaAMeBKwd7MZLt7hqAoZIdYV3ASyyCFQtKVhsOHMtllIFiFHzAU5xIUyNYtp8qgVFUDF00NT1bDYiE3kCmRZUWSqEksprn+G2gwmaC8my1LGeKQoLrXuWpRsX7fz7QTGfLMSq4erT10M3nQe7SJXC1IiGhYbhtmkZlo1fP2eTsOMDzsSETdTnlnUh7QFuAAAgAElEQVT3dXnwT5y8/b/sNUWy3PKKydoMs0gEvcem5aS4iJrYeotu8zUdS62++FedLe4aDYqbF7Vz5IcVQbM0GGe7PaT2LT7eSfcTN70Sf3Ttqe6/RRYSf/vCEwEA874kvl4LNb0sEkyO5CuGFrGLLWqByvj465zoYfacEdEiEWbkyzAsK/X747bmJUxqC4MZ8/dbCSRL7cVp1ob9WVMtKdj9ievxlotP7to8CXr+pMVNmzMtV61w02tfxH1c7znOe9qzxSmBwu9ji7N1hRUAil8EYhuoYucmSdLBDEvcxl7WTFQ0yJLzLBPdDgY491jRPIFY0YcpEikhrJtiXN3EqmWsrGKltbsj8iHAUq/u2jmLetNEQzddE2RRlBQZzxxagm076UsTFVX4A2WxYXTsCItWcjDD4H5PhPNM0GfIEhlKgh663snneEV1J0JZtIN5yUoJxFR3Iif+fph/VcHnvEQAXpNfkUqvmVFnh3DWVwTq1Y+D/VoSpV47WYgnHUwOTRUSrQRiC+zH9y/gmUNL7uvyLFCZ3189pAgkwhOIVwn0yN5jkCRgIiOz/DC8SqC5ARWissCvgha5IaDIEmSppQTSxSWqVUOKQEwNlya9zosmy5EtkWlNoQFPMbTAhrgvzNawZ7aGqqYIV+OoCYyzm4ZViFYwwLkWp0dKmF1uwjCddEWRGyZlVS5cOxhbG4221nbUDtYNFYGIXFNttW01DUtoX/yGiQoA4Hc+90uc8dHvo66bwheoqiJhsWHgZ08dxnytiakMdvM+ePODHdVt0UUmVkmfGYJJqCgC46ubJmxb3Pv/2P4F9+vJqoYGk0QLvEaDCkpZFYHO2TwJADh57UgmxwfgpvZkqTYi+ssp68cAAOvG2uOPyIktUzgypSajVyVQuwCZ3BOIZ4GnKVJ4OpiAdjP/awHAW794D67525/jgReOdXw/DbFKII4IcUmSXFPctByr6fjmA/ugKXLfW0G8nkCzA2pJywJ/UUZ04ihTXrM5i/AiUL1dKBarBAov5vIUmdj9WdRo7GM1HVf9zc/w9fv3ZqJEV2QptJDOEOnz2A+mRjTM13Q0TRuaLHbscopAxbqW2NqIbfCHPW9WM2T0QeSaaklxIuIFK4Fedvr6jn83dFN4z/EHrj0NP3j0IPbM1VFrmm41WiQ/f+pwx0M+K2PfosrRsyBoUsAUU6LaqZ49vOR+XVJkjzeEuGs0KPEtq+vnXVdux3VnbcQpG8YzOT4AfPz1L8J7r96OSWpdHApu+/BVmKw6n+Ubzz8RN33ncTTN9G1CQYyETA5ZslRS1RGbaycpAokwVtYiPIHcEAJBiin/c/fAQh0AX5EprghkWrbraZIGVZagc7SDsQX/Oy7bmvoYaVE9ZsFMfTI9Wvwxze8JJLpYzzxLVgT5LwKdGyXeVhhRhVZVkdAwQtrBOD2Byq33t2jqDcaBhQYMy8a7rtyG3zx3s/DjR7XUMgyBPo/9YKSktjyBxCuYyppSvCJQ6xm5ftzZ9D9W16N+fVVSnKubWJWUNWcB3BScDuZPKdJNW/ikZOu6UQCOpNtRGmVzu3mVQFkpOXi9jIaJoPe41mp3EjVhqHiudd2y0GiKbwcL2mXMqgikyFKmBSDAmfRvWTua6WsQ/WPz9AjGK864U1JlXH7qWgBilUBszPe3JTGRTa+eQEnEJ7zRz0Ar3TK0HUysJ5B/TGD+ZDxFJjaO1ZshhSyOdDAgOj0tCex6OOu4idTHSIssta+R2VoTmiIJb1UfBP5nY1l0EcivBBIw3/JuunjvN1bs5S20RpkTO/dAdoXWvMNUcJdtX4tt68aEHz+JWlA3LWhqMdrBgHbnhGFawv0dy6qMlYJdS3prLNgw4bR9z/navgkqAhE5p6opaBoWGrpYJVDYa4lEU2SMl1XMLjcdpVFGbSr9UAIVaTckayZa6oST17Rbm+589ggAcUZ8WzyTHsO020qgjO+BfqR3EUQa2KLx4b3HhB3TLQI1Oye3vfretH+th4h4jrGipMjuBNePIeD4XvyKigf3OO+/CCVQrWkE/pzHEwhwNnl42sFcDzPB6uAkeL1KvnzXcxgrq4VIJ4pD9v0NI4LnQ7Ik4V/v3ZOZJ5B3s013xwe+4yuyHNrWaVl213vWC+2xrVjqDQYz68/KD8uruAujaVrCErb6QaWkYK7WxJfufK7Dw0oETxxYxA8fO1ioouKKyYpAjhJodpmUQH6Kc3UTqxJW1FhaMTIvAmUx4RurqKg1DdQFFoG+9s6L8aHrTgMAvPG8EzraAkRLQH/8gSvwD285T+gxi85LTpzC//n6s3HLey/Fe6/aDgB48qAT4T5REaOY+vsbzsWFW2YAOBNOJmNlBagsWEO+T0SOYS0B+481hB2zUmrH6nphY2pSZWUvpuQilEBapBJIrCfQS06cDj4HjmcNGycXGsFFIJ50MIB5JqVf/LpG/APwF/OmFmmK7MYbFx1/Ms+LT5wSevypEQ2jZTWzdjDv/cZUZrybbpER8ZyF0GqM+XreYWb9WflRJlECFa0drKrJeOLAYqavcXhxJdPji4RtlExUHSVlUVsjs6Q4VzexKmGT8OUVQ8hDPYosJnxVTUFdt1BvmsKKTBdsmcF7rtqO4yYrsGy7sx1McKFs+/oxXHPmBqHHLDqSJOFNF5yIyaqGP3r5qdAUCc8eXgYgbtdq/UQFn//d8wE4k8HZ5SbGM0iX83LFqesyOzZB8HLZ9rXCjxnWMtE02SI8YTtY6/+TeQLxm8qWFDk07tYQEEHvJawFlUedMl5RociSm37lx+RUQfAaQzcGWARSPYWBFcNyDe+LzrJP9SV6Pnfp9nVOOlhGxtBBSiDedjAlom2RtwhUCWl1LQpsbMjKikCV4wvFRWwHyxqecbXfsMJtVXOKQEU6935BRSAi17BFr2HZmbU6MbLw7Km0enQbuiV8gN53rIGb792Db96/z/1ekXYthgFJcmI5d7aMnEWmuLB2juWmiS/esRtZT0UG0fpAEEnx+7iJoBLQDnbLA3vxyZ88DSB5ocP1BEogPmkrddL/PdGeQGKVQFkgyxImqxq+9eC+wJ8bls3VzqZGtNkk4c5njwIQ68GWFFlqK4Hquik8RWtQ+FsuRaOpEpZWDLzzn+4FIGY+5/UV8haB2L3HO99S5XBzYpPTGDqs1bUI7Jmr4W9++BQqmpzZ5m+SQrETRFCc+68f41VRiorPHV3GH371AQDt9+Xzt+0a5CnlkuK7zRFDjXciOCm4FeYf3nIe/ur7T+DpQ84CPigtiZdqSUFDN4W2g/n5/O3OwLZ9/VjmLXNENzOjJVeCO1oW9xmzXvRbHtgLILx1QhQUrU7knXdfuQ07ThDXRqIpMsqqjMWV9r31B62JYy+wtZqdwBMocyWQe3xxz4K/eM1ZkCQJf/bNR4QdE2gb6vvh9wQKb7NJwqFWy8MJ0yMxvykeVZZg2TZ004JpiQ+sGBRvv2wrdh9dRkO3cNVp4tVNB31toiMl/uWN9733qkZ0tx2MNx1MDo0pNy0bCocajpmJLzaK54Ny29OOx+I1Z2SnQleVeE8gw7QzC1vJgqxa5wDgtS8+Dt98YF9hikA/f+owDMvGi0+YwgnTVQDA7qO1AZ9V/ijO1U2sSrw7LcwjRRTXnLkBP/rAFe6/sxAKVlrpZvWm+Ah6P3//lvOGwkCyaEx71D8i1WqyLEGW+pfuMSyLDWJ4+eNXnI7rztoo9Jgzo6XQtqSksNalBN1gQtK7NEWGZQfL20WngwHAWy4+GTdcdJKw4wHAK1+0EXbIG2aYfMlITkR8+if6XE3HjhOmBqIEYi1CbhjAkIzL68bL+MwN5+FLb7sAv3vJFuHH9y9ORSyIOzyBvO1gRvZKIN6I+OlRZ9NUtEFwP2B+QH/9mzsye42oZDZG0drBXpZh0ey3LjgRANyk2rzD0uVu/v2LMToE6YpZQe8MkWu8VfisPYGyqHBXNQW3P+NIy7OezE1TjPtA8E42RbcsOjuF/eljzqIdkiDyzvRIiTs6ltXeE3kCCfDsYeNM07C6ChVtU+F8L140RQ715OBthVHlcIVFEuZrzYEZ5Suy5CSithZbgyhEFZG63vl5i5hvdXgCeY2hLUFFIEXCocUV3L1rFhf4NjkNk+8eGCur0BTJLajkEdu28W/37e0qwt/61BGUVTnTa98ptsZ7AhWpgDCe4blWC+QxZds2bv7VHoyXmY+m1fEz2ixvU5yrm1iVeNvByhkvUndsnhR+TO9OQ9ZKC1HJVERveBO7yorYzziq7UME77pyG/7nz54FkO0uEkHklcmq5qbvpaU3JZCAdLDWc7FpWqiic8zJ0hNooqJioWHgurP4x4pIPxTLRonjeem0g6Uvns8uN7F9/Vjq/54Hlg621GpRHBXQ1rQa+K3zT8Avnjos9JjeOZvXW6dtHM83Jy215gtv+Myd2P2J6zt+Ztl85uiSJAkZ27Jk15FlfPDmBwN/9mKBbb9BJFMCFSsdbONkJbNjM6uDpZVsbQlEsPtoDXvn626yoretsmlamQsKigQ9XYhco3UogbIZjP0PX5G84bwT8NMnnYlJVXAR6+/e/Gt471fuB+D068o5NgIdZkY8u1WipcMVTcF8hjt5H37F6fjwK07P7PgEkXdKqoxajW9i25MSiHn2cBkfMyPq7tfLwhOI8dDHrkNDN4X4ZESpHA1uTyA+Y+i55WZHm28/YZ5Ac602nqzSkYaNV529CdecsR4/fvwQ3n3lNiHH9IYlzHnaqlg7GO99MDPa/mwbutmhXjI5zdGB7DeReDnaUgB99oZz8VJf+mPWm6aKEt8yqpsWt+9TPxmvaNj9ietx8ke+K/zYbDwsQnvh0SXH0+2v//M5ANCxNmo0qQjkpTglTmJV0s92sCzwtgqJTrfxPiSLtFsxbHg/B9EmgtVSvHkhQRDp0RQZTdOGYVqpC65uOlhPSqD0YwUrkASNDVmng1U0RciGg6ZI0C0Liw29y/fMtCxuT6C0SqCGbmK5aWZqshqFIjvFsWdZ4uSAzqOIsDmiqPmQ99nubRllbYy8mz5TnkLj3vl6x88Mi08JBLRSBHNcBNrX+puPm6pirKx2/C/rdMMkY8TBhUah0sGyZLKqQZLaXjt5Zn/LJH5dSwnkpQjtbP2Erm4i13h3QrKOiM8CrzxzvCJWeOedoPDuGBHp8fati564eD/jza2EA4IgxFFWZTQNE392yyN48V/8yP1+LwoMNx2sFyUQx1jBCkhByiMRnkP9QJVl2DZw9sd+iOs/eWvHz3j9UFRZCvUbioPtdA9KCaTITiHvpm8/BgDYMJFdi8ewwXx7RLVAeYtJgUUgzmLTJs/88KbvPNbxM15jaCDadysPfPN+J/l0/UT3Yj1rVFmGadmhY/bschMLDaNvwRyiEW17oyoyxstqrtsLGSxRd/1493W13Mx/O1s/Kd6qmlhV9KMdLEtOWjOKf/m9i/DZG87F9WdvEnrsSc8ipV4Qx/5hxHtdijac8xaBvv3eS4UemyCI1m65aeHr9+11v3fGpgl8932XJT6G6wmU4HdFpHexx2KwEsiCJCH37cHejYtnDy93/Ew3La4FtqqE+w3FwXa6va06/USVZZi2jRXTwoVbZqgI1AOXn+K0FB1ptYOI4OcfuhLXnLGhw7xYlCfQlaetxz++7QIAwGKjc3HKGxEP5F8JZNqO0m39eP+vcVYkD1MDLbSKHS/dtqZv5ySKX/7Jy3Dfn14r/LgVTcGKkf+1hirLqGgy1geMnUVoZ+sn5AlE5JqiF4EA4OKMHiJemfjSSv4H5mElywQL5hGgyBJ5QxBEBmiKBN2wO0ydX71jE46fSq68cz2BEhQeRCqBzADfG8Pii1fvF1HpZQanH4oqyzCsdM9EpviYGpgSSMJSw0DTsHDFaesGcg5F5fiWWlakee1Ja0axebqKu3cddb/H1DW87d+KLOHyU9fh+nM24fH9Cx0/My2buxXJaXXNbxFobrmZSSBLEhSl3VIb5DTBxuk1AS1FeSerwnFJlbGS46Iio66bOG3jRODP/El0q51irqqJVYN3oijaU6foeOXqY+Xi+SUNC1kaGHqLQBRrSRDiObS4ggMLjY7FUq/+cxLSeALxG0ObAa0MJqepcr+IWuAaJt8CWE0Q/xzE52/bhRu/dA+AwXnxqLLkKllmBlSIKiozo86CfVxwUurUiIaFhuFeU8wYOqqQ2QsTFQ07Dy/j8GJbwSTiPs6zEujTP38WD+89hukB3mdAuBLIFFCsHzbybjTOqOtmaBDPbIZBK0WEVtVEriHD43AqmoKP/vqZuHDLDN5/7amDPp1VS5ZFoBNmnJ3NIjx4CaKI7Dqy3PW9XlWnPXkCuZ496Z9tsruA6R4XDAEKgn4QtYB22sF40sHSGUPfvWsWIyUVH7ruNGxfN5iIeFlut7INaoFcVHZsnsTHX3c2bnrNWUKPO1Z2miZqLX8Y3XRaLkUVW7etGwUA7Jmrud9bbBjcPpJlNb9KoF/udJRVN166ZSCvz9SU4QmF/G27w0ZJzbfHFKOhm6Hz8qJ6PGVF/mcKxKqGikDRvO3SLfhf77wYJ60ZHfSprFpYjGwWQp1Lt1M7AEFkyXJA60jPRSC5F0+glhJIQER80Hy8MEqgiGe7iHawNIuV2VoT29eP4T1XbR+Yp5JXeUDJYL0hSRLefOGJwlv5WMt3o+W92DRtaIosTJ175iandcXbajNXa3IXAfNsDD1X03H5qetw1nGDaQfT3Haw4PfHVQJR6IqLVhQlUNMMtWkowvn3E1phE7lGlNyWILKC7ThkoQiaJh8ggsiUIP+QXpMo2VMqKK3LjwhPIGZEHbSAMTjj1ftF1DnqpsXXDpbSGHq+1hx4C5a3gDeohDKiE/Zs/8vvPQ7btqGbFrcfkBc23rAFqm3bmKvp3Ndintt35mrNgc5vlJh2MMNt26VlMuPAQgM/ffJwIsXrIKnrpmul4CevyrhBQVc3kWtICUTknSyLQKdvmsDFW9fg/ddQux9BZME/33hh1/d69gSSevEE4m8ziPKzKIoSaKQU3upimDZfO5gsh7Z5RCGiBYeXziIQbQLkAbagvOWBfThW17nbFf34i0B13YRp2dzXoqbK0FPcB/1gdrk50CInG0PDisXkCdQN86zafbQW85uDZWnFcFs4Ge++chsAUgL5SbTCliTpFZIkPSlJ0jOSJH0k4Oe/LUnSQ63/3SFJ0g7xp0qsRqgIROQdNkEM23ngYbKq4V/ecRH+4JpThB+bIAjgvJNn8Oodx3V8rxxiKhlGT55AItLBlPAikGOqnP+Fy7Qngv2kNSMdPzMsiysIQpWl0DaPKOq6iZEM0x6TwIpAkuSM/8Tg8W7wmJajBBIZVMKKzqwdrN5qO+NNHs2rEkg3LSw2jIG2O7oJi2FKIJPfwH9YyfM7YpgWjtX1rgLjH7/idKiylNv2yEERW2aWJEkB8CkA1wLYA+AeSZK+Zdv2Y55f2wXgCtu25yRJeiWAzwLo3l4jiB6hdjCiKFR6XDgSBJEP/LuGvXoCMSVQEpW8iHQwRYpRAhXgueldAHrfC6fdxobGo5RKaQxdb5qux9ugYAW88bJKiag5wbvBs2JYaBp2Nu1gplP8qbfMa3k3lryR3rWmgbt2HsXVp2/gOqYI7n1uDsBglW7sPgsrCpASKJyGkT9z5WN1Hd+4bw8WGwZsO/jaKoqnUT9JojW8AMAztm3vBABJkr4K4DUA3CKQbdt3eH7/LgCbRZ4ksXohJRCRdzZOVAAA77x824DPhCCINPjVH722g7F1Qi+eQFm1gzUMU+gCNSu8KhfvQqxtyMqnBOq1DcaybKwYVqZpj0lgCoUGLVZyw2i5swgkuh2MFZ1XdOczZwlGvNdiSWkrH/70m4/g6/ftxQ/ffzlO3TDOdVxePnfbLgDAKQM8j3hPIEoH86MpzrjKlGp54lsP7MXHvu2UJWQJgdd4SaUikJ8kRaDjAbzg+fceRKt8bgTw7zwnRRAMKgIReWdyRMPuT1w/6NMgCCIl/ol+7xHxvXgC8ReB5IgFzNyyXohUqRGtPf3UjfbfYQhI5VEVGUaPsn+2uz34IpDz/286/4SBngfRxttasmKYrSJQFkog1g7m/D93Eciz6N15eBmA43s1aI7Vdew4YQoXbV0zsHNop4PFeQLRGoTxTzdeiN/67F2uUi1PHF5qQpKAB/7s5SipcmArpabIaObUI2tQJLm6g57Ege+iJElXwSkCfTjk5++QJOlXkiT96vDhw8nPkli1UDsYQRAEkSX+gkyvrZ0sKTqRJ5DJv7iIMjV1UnfyXwSqlNp//3y96aofmHJB43x/ekkHm11u4tF9CwD4fVh4YUqgkfJgDaqJNt6o9hXdctoVhXoCdRtDAwI8gVQZdd3MVZqTZdl4eM8xbGopqAdFrCdQ6/tUA2rDipKNHBaBdh5ewkRFw+SIFnrflEkJ1EWSy3sPAO+WxGYA+/y/JEnSOQD+AcBrbNs+GnQg27Y/a9v2ebZtn7du3bo050usMpjXwvknTw/4TAiCIIhhhHnsMHpOB0MPSqDWgoyny8BtZQhY3M3XdEwVIFXK27LW0C286pO3AoDbxsWVDtZjRPxLbvoR/vOn7wSQjcF/T7Q+017VaER2jJYC2sEEfj5MCcT8e5abjlqH91rcfcRJcfqXu1+AlJP91Fse3Iu6bmJmbLCF6uTpYHQfMlhxpZbDdrB/f+RA7OZNWZVz6Wc0SJJc3fcAOEWSpC2SJJUA/BaAb3l/QZKkEwF8HcANtm0/Jf40idXMzz54Jb70tgsGfRoEQRDEECLztoO1fj3JjrtpWVBlyd3gSINbBAqQtteaRmT8el7w//2sXWW+1gTgtNmmRZVlmJadSgExNeBELt1iRTBafOYFSZJw02tfBKDdDlYSGRGvdBaBjtV0APzGyc8cWgIA/OzJQ57vDlYV9MJsHQDwgWtPHeh5tD2BgpUhIrzbhg02Ns63rs+8YFk2TMuObS+cHNGwUM/XuQ+a2JmCbduGJEnvBfADAAqAz9u2/agkSb/f+vmnAXwUwBoA/6P1YDds2z4vu9MmVhMnrx0d9CkQBEEQQwqvEoh5AiVZXhmWzb2wiFICNXRr4C1NPMy1ikA8LW3eXf44RZHf5HTQfkqsXYFa4fPFjs2TAFg7mFhPIEmSWklezrU4u+zcA7zXYpC5ca+G6aKZqzUxXlGxdqw80PNop4OFKYGsjt8jgKnWmDzXuj7zAvO5Ovv4ycjfmxkp4cBCox+nVBgSbRfZtv09AN/zfe/Tnq/fDuDtYk+NIAiCIAgiW6ZHO3fcy716ArX+P0k62Lcf2JcqvtyLGuJnYZgWmubgE67Ssu1Pvoe/bCkuuIpArQW6YdqIeyvuePZIx7+nB1wEcj2RSAmUK1hheMWw0DRtjJTEfj5lT3z1fK0JWQImKnxKoPXjFTx7eBkVTWFdhgP3RJlbzodnWVw62Me/9wQAPoP6YaOkyhgvq5it5asI9POnHY/hqZjramqkhMf3L/TjlApD/jXDBEEQBEEQGfHmC050CgaqDNu2e/bikHpIBxurqNzx36w+4PezYMctShHoC289Hzf/6gV87+EDAJwF2Y8eOwjAeZ/S4kZuG2asKurQ4goAYGpEw+9dthVb1gxWeby04uxqj5IxdK7wXlO6IVYJBDiFZ9YOtmJYKKtKV5tqr3zyTb+G8//yxzhpzQh2HXHaLfUeU/NEs7RiYiwH17ZbKA4ZtGsrBiarGo6fqvbztHLP9Ggpd0qgPXOO99Wl29dG/t54RcVyDv2MBsng70SCIAiCIIgBoSoy3nbpltT/PVurJfGg0U0bl8RMVuNgyTaWbwHDWpsqBWkHu+q09XjwhXm3CAQACw3Hs4GnkMUKPw09fsHLFoE/ev8VWDc+2BYVAFioO0UgXhUIIRamDmTG0CVVrEKk5FECGZYtpA1p3XjZTQhjDFoJ1NDjC7P9QI3wBNJNC8tNEx+4dhuXd9swMj1awlzOPIHmlpuoago2TkYnzlU0JZfx9oOE9KYEQRAEQRApcT2BEiiBmobVkYyVBuZh5N/FfvLAIoDiKIGA7kLWPbvnAHAWgVr/bZIJv2nmy/uDFcEmqrRHmyfcdjDdFO4JBABlTXELNKZlQxHUhlTVFDQ86ofmgJVAdd2MTXHqB6wdzAjwBHJ9yQbcGppHZkY09/3JAw3dxN/fuiuRiXq1dY/xtmMPE4O/EwmCIAiCIAoK2yxO4gm0YlhuJHRa2ALRX0B54oDjd3DK+jGu4/eTsEINj1qAtfP5TZ+DcFOAcuL98ZevfRFecdZGnHvS9KBPhfDA2sGapgXdtIUXgUpK2xjaaCUIiqDaUj+wkYK1Gw6KetPMRZGafX5BxtDMaHiCoyV1WBktqwO/hrw8ddDZ+Ni6Lv6ZV9HaLZ2EAxWBCIIgCIIgUiL34AkkIl7am37lZb6mQ5Gl2JSUPBG2oChzFMrYZD+REqj1HuZFCXTKhnF8+oZze06oI7LF9QTSHfN14UUgVe5UAokqApUU1HXLlSkOOt67oZs9e65lASvEB3kkseJxHopVeUNT5ED11KBgSXrvv/bU2N9lGwtJNgdWC1QEIgiCIAiCSEkvSqCmACUQKzr5/Sxma01Mj2jchrL9hO26e6loMpcXB1u8NWKKQIsNHV+5+3kAELboJoYTVZGhyFLbE0iwcqysto2hDdN2EwB5qWgKDi008OCeYwDai+ZBUdfzogRyPr8gjyQ2buTBuyhvqLIEY8AthV6++9B+AMBMgta9Sg9twqsFKgIRBEEQBEGkxC1YJPEEMvmLQGpIvPGxuo6JarEMhV/z4uO7vse7SEzaDvblXz6P5446yTKiFt3E8FJumSw3M0gHy0wJpMn45a5Z99+D9nNZWjEwkoPiChuDV4KUQDopgcJQFRl6jjx1bnlwHwBgw0S8qf9oyWnvW16hIhCDnnoEQVagII0AACAASURBVBAEQRApkRMqgUzLhmnx+4nIIe1gjaaZiwVWL1x75ga872WndHyPd/HFkpziTHC9C2ISAhFxMH+degYJVx1KIEHpYECnmuX0jeMDjffWTQuLDSMXhsvMnF8PUAK5KYtUBOpCU/KjBGoaFpqGhf969XaMlOL9m5h59KALoXmCXK8IgiAIgiBSEucJ1DSsDjNKUUogf9EpL60WvTLjS3bhjbhnC7y4OGwJ7YU2RUETcTitVSuwbfEFgpIqY/+xBp47uixYCeSc53hZxfqJCnYeWRZy3DQwP6IkrTtZU1LDC8V1agcLRZXz4wnEWhvXT0RHwzNY8XGQhdC8QUUggiAIgiCIlLS7wYInxzd+6R7c+vQRvPOKrQCAiQpfy5YSogSq6ybGysWb1k2NdC4KeQtZ7gIvpggU9nkRRBDVkoIfP37Q+VpwEci0bBxZWsEVf/0zbFs3KqzdjBWrypqCkiLhuaM1zC03B6LGmWfR6yM5KAIlUAIVsaCeNZoiQbfyoQT67sOOH9DahNfylKsEGqw5ep6gdjCCIAiCIIiUMEVJmBLo1qePAAAOLawAAH7z3M1cr8eKQKZvR7bezEfyTq+wNC+GqCJQkN+Hl7zsaBPFwHtdilaJeFPynp+tCVMCTbY8wi7cOoPLTlkHwDGQHwRMuZEHJZAiS5CkYCXQfN0pEkyNFMtfrR+oipSbcXOh9Tm97IwNiX6/0kpcpIj4NlQEIgiCIAiCSAlbr9kxnkBHllawY/Mkd6FGYelgvtdrFLQdzN8ex7vALiutyX5MCgylxBC90FEEEnyf1Twm5ropzhOo3Fr4vui4SWyadNpmBhWRzbxY8lBckSQJJUUOVAvOLTdRVuVCjqVZo8gyDMuOfdb1g7laE1MjWuL26qQK0dUEFYEIgiAIgiBS4noCxaSm3Pr0ka7Wp1Sv19rF9qaDHavr2H20xu03NAj8rS9s4ZqWpMbQjQEtholi4vWqEn2f+ccFUUqgsbJzziMlxS2uNjIqfr7+f9yOj97ySOjP/+Qbzs/yoAQCnJYw/xix0NDxmV/sxGRVI5+wABYbjvrmnt1zAz4TR1k208PzlIpA3RRvtkAQBEEQBJETekiIF+bZo8pShyfQgWMNAMBxU1Uhx+8nJV8RaJIz5j6pMfSxOnlDEMmpetoWLztlrdBjf/TXz8AFW2bcf6uymOXZ71x0Et539Xb8px3HucqWLBRwDd3Efc/P4x/vfC7w57ZtY67WxPrxMjYmNPLNmpLarQR6/mgNAHDFqesGcUq5577nnOLP//8fTw/4TBwlUC/eVkxdp+ck3SwPUBGIIAiCIAgiJVJMOpgXURNQRZY6lEfsuGcdNyHk+P1E86kqZkb5ikCyLEGVpdgi0KC8UYhiwto433jeCRjnNHf3s339OL72zovd4pIoJdD6iQo+8PLTMD1acs8/i3awuNjtpRUDtg383mVbc6Ow0RS5azxmvkVvPP+EQZxS7nFDCXLgCzS7rLux70mQJAklVY71iltNUBGIIAiCIAgiJUk9gQBxu/CK1KkEYl9rSj4WWL3gVwKJSC4K2uX30jQs3P/8PPfrEKsHdntnGR3OCjVqBvcxO+8slECzMbHbc8v5M1sOGiNYMWsQ6WlFgD1n7tx5dKDn0dBNPL5/oeekuXKID9RqhYpABEEQBEEQKXE9gUKKQFvWjrpfi/Lj8C9gjNbupqg2kn5S9iiBdmyexCXb+FttSqqMlYjJ/jOHlgA4i9L3XrWd+/WI4efZw841sybDAgFr2RIVER907Cw8gRYbRvTPV5wi0HhFTDusCEqqDN2naHETzHIQY59H/uo3zgEA12R8UDy2fwEAsKHH1kJN7VZ/rWbyczcSBEEQBEEUDNcTKEQIdNxUBc/P1mBatrBd+KqmdCzm2GImCwVB1ngXvLe891IhxyzHKIHYjv9nfudcXLh1jZDXJIYbdu9efcb6zF6DFWqyUBtVM2wHixvX2PiUJ+N6TekuFM8tNyFLwASnL9mwcsamCbzpghPwk8cPDfQ85lrFumvOTBYPzwhLhFut5OduJAiCIAiCKBhyjCeQbtqu2bGoBVilpHQsvAzLmdhmoSDImiwWhiW1O/nHC9vxp7YPIiksTW5CsB+QF1b8ySKevN0OJn4R7E3aC2qLZQvvkpKf2PWgMeK2Z45goqoJ82QaRiqakklLYVIsy8bnbtsFoHfFlqZK1AbsoXizBYIgCIIgiJzAlEBh7WCGaeGkNSMAgN996clCXtOvBGJGnWoBFy+VDBa8cTu+LBlsinb8iYTceNlWAMC68XJmrzHSKtRUNPHLM9Z2mcUC3nvMWkCh2y0C5UgJVFIk6L4x4ulDSzBzYHqcZ/zPnn7z2P4F3PGs40m0fqK3e3F5xcQLc7UsTquQ5OduJAiCIAiCKBgSogsvhuUogXZ/4nrccPHJQl6z6tuNZT4HRVQCTWTgE1JSlUhPILaIydLklxgubrx0C3Z/4vpMipYMZnSbhW2JJEmoagpWMi4CBSWFsfEpV0UgnxLIsmwsNgzccPFJAzyr/FPVFOimPTBvnSNLKwCAr77jop7vxd++8EQ0dAtmkijPVUB+7kaCIAiCIIiCwcQ3VsDE0rZtPHe0JtywuVpSOlrLWGpLET2B1AwKV2VVxooRvthl712WC3qC6BWWnpWV0qKiyZkogeY86WAsCcwLK8jmKb2w5IuIf27WUYisGctO6TUMsML5oNRArMjYqyk0AKxtfbZMCbraoSIQQRAEQRBESqI8gW575kgmE86yqnR4e+gFTgdjjAhU5cRFxNd1E6osFVI5RQwv61sL283T1UyOP1JSsbwifvH+nYf2u1/PRiiByjlSAmm+ltE3fOZOAMDGFMWF1UQ5Q4PxJMy2ioxpEtxYkTVIrbYaoXQwgiAIgiCIlER5Ah1acKTr77pym9DXLKlSxy428wTK0057L9z+kauFmuGWVRlLK+Gx1XXdzMR8lyB4uHT7Wnzl7Rfi106czuT4k1UNx+riF8BeI+Wg4kBujaFb52XbNo4ureCczZN4+Vm9JU6tNsqtwnmU8X6WzC03ocgSxlO0EZdV5/pbycAcvYjkpyRLEARBEARRMKRWFSjIZYC1XpwwI3ZnX5VlGN4iUCsdrKipNsdPVTEjMKkrzhi6oZuokB8QkTMUWcJLt6/NzKtqelRzk/FEMrfcxLknOYWroDYh17NMzc/4VFLankBLKwYsG/hPO44jdWAMzNdpUFHrs7Umpqoa5BTPOqZEG1QBK2/QlU4QBEEQBMGBLAVHI7sGxIJVJ6osQfek2OiuEoimdYCzUIkyhq43zUwSmAgiz0yNlHDf8/ORKrle2Tdfx75jDbeNKshziC26Szkan7xKIOZjNJWixWi1wZ4xb/zsXQN5/a/88nlMpkx1ZOc+qAJW3sjP3UgQBEEQBFFAZEkKbAfLyoBYVSRX/QO0jVcrKqlbAGfHNy4iPu1CgiCKyrZ1YwCAF2bFxWTvProMADh78ySA4HYwVgzPkxF7SW0bQzMfo5lRGhPiYEqgw4srA3l9SQLWjKUr1rFzH1SyWd6gIhBBEARBEAQHkhRsDF3XTWiKeANiVZFdHyDAs8gq0bQOiDeGnq3pbhw3QawWXrptDYDONC9emArxnFYRqBGQyldvtorUOSoCeY2h2ftBY0I8g/SdMy0btg1cun1dqv+enTspgRxotkAQBEEQBMGBJEkIEAKhrpuZqHM0udMYuqGbkKV8tVsMkpIqh/o+NA0LD74wL9SDiCCKACtyBCV4pYUtqMfLGiQJaAQogeq6iZIq58qzzDtGMJ8kGhPiKQ0w4c1tr0652cHO/a1fvIcKQaAiEEEQBEEQBBdhnkCLDQOjZfFBrKoiw/RIj+pNJ+2KmVSvdkqKEjrJZ+0radJlCKLITLfanUQqgdzkL1VGRVUCPYEauolKjuLhAUcJpJs2bNt2I8OnqQgUS9nzOQY987Kkzumx5z33nzx+UMg5FZl83ZEEQRAEQRAFI8wTaG65mcnusqpI0L1FIN3MLFGoiDjG0N2LUaC9aL3slHQtBQRRVJgSaK6mCzsmUySWVBllLbgNs97M3/jkTYqaqzWhyhLGMyjYDxve1uYo8/0s4PXY8567EdS/vcqgIhBBEARBEAQHEhDYDnbrM0cyKQJpvoj4e5+bQ5lMoV3KqrPLbwVM9JueRStBrCY0RcZ4RRUaE8+KPpoioazKuO2ZI12mwXXdFJ6QyAvzh/n5k4fxy52zmBopkZIyAd5xsxGg+sqKXzx1GP9y9/MAkLqg6H1Ge4MVVitU8iQIgiAIguDAUQJ1fu/w4gqahoUs1hWq4ryeZdmQZQkvzNYg58hvY9CUPLv8FblzwaC3Fq1l8k8iViHTIyW3/UkEK14lkKrg2cPLeO2nbsftH7na/Z3lFQPVUr6WnMw/7R3/dC8A4JLtawZ5OoVh3VjZ/bqh96eQYts23vFPv0JDt6DIEk6YHkl1nBlPqthC3RB1eoWFnoAEQRAEQRAcOOlgnVWgI0vObvibLjhR+OsxWbve2s3ULRtvOO8E4a9TVLytHn7Y9zRSAhGrkOnRklAlULuoqkBtFaL3ztc7fmeu1sxd/HrJo5x815Xb8KW3XjDAsykOa8bK+PjrzgbQv5St5aaJhm7hA9eeioc/9nLsOGEq1XEmKhoe+T+uA0AJYQAVgQiCIAiCILhw0sE6i0BzGSbOsMWW0TI2bRpWJgbURcVVAgVM9F0jW1ICEauQmRENu44sCzvegYUGAEBTJYS5rOw6spy7+HVv1PmmyQpUGg8SM9Yy1X9037GOlMqsONraUNk0WcEIp6LMjYnvw3nnHbriCYIgCIIgOJAldC2AWAxzNsbQzvTNMG3XnLOi0ZSOwZRAQcalbNGi0aKPWIVoiow9c3VXqciDbdv47C92AnCKqkHm+C/M1jBX01Ob+WaF19uGouF7gxXQ3/Xl+/Dhf30o89f7zkP7AQBrx8sxvxkPO3dSAlERiCAIgiAIgougdDCWwDM1Ir4Ngu1m6pblJqbkzXh1kEQpgVYMMoYmVi+XnbIWAIS0hDE1xStftBFqWBForgYAuOaMDdyvJxKvEjBv55Z3vFHr33l4f+avxwr3l25fy30sSZKgKRIpgUDG0ARBEARBEFxIAcbQrB0sizYIVW4rgZq2M5mlIlCbkuK8F0FFIN20W7/zv9u79yjJyvLe47+nrn2d6e6ZAfvMMDcYAhOG63AXFBWDw1EhgguCURMjS8M5ickxRCUrIZqLGpfJMXGFcHIMiTEhhyiKHgVNFIgC4TYMMMjAAAMMgzAz3T2XvlV39Zs/9t7d1T1V3VW9a9dtfz9rzZrqqn15dz21q3Y99bzvSxII8fPfetolzUy3HcZYzju/Nq/tkyQVm3BpcNhLhq9b3hl6f9VUmARutCqlRldYRVmL+QhGJ/LKphJVq97MJBNUAokkEAAAQChmR04RPzCcU3dbKpJuRym/EujeZ/fqs997WtLip81tRWWNCUQlEGIoSBaPVmF672AbwTbnjosmzXSL7Y2gIjIMzv/FSxZkfhJRTH85x1guX9XPt0wqUZOxjBodZwAAAEAICTvyC5A3I040Y00E3cEefGFAA8M5XXvhel24YUUk+2pGmekxgY78ojvmf3FlDCXEUVsmgiRQxjuX5lZDSjMVkT0NNzA05/9iFXb7q0USaHQiX9VK1zSVQJKoBAIAAAil2JhAA8O5yGbECbqDvX5oXJ2ZpD615cRI9tOssvNUAo1NBkkgKqcQP8GX6bEqdAebOx5ZsTGBBoZz6s6mGq7yJmhPshb9mVpMviDbV4MckEYnpqqaBMqkSAJJVAIBAACEYpr9K/jUlNN/PLsv8kqg1w+OqZeZbY4wXQlUpOR/LJeX2ezBTYG4mE4CFamSq9TchGrhe+DXH9mtsYm8brlvl3o6G6srmDQzJtjyLt4/K1WYBCqS96uq4fFJfXvbHmWrmQRKJhgYWlQCAQAAhJJImKYKLoxfGRqVJPW0R/PlJ6gE2ntofHqgV8yYniK+SJeXoGuB1eInbKDBdLV5X/0Ojk6G3tahMW8bXVlvm4VdYv/Xbdu01h8M+tgVXaH3VW1rlnXonPV9+sC5a+vdlKZzzvpl07cni40GXkWP7z4gSVq3vKNq2+zIJnV4PPzrv9nxMwgAAEAIyYQpX/AFKJh++dKT+yPZXzAw9P7hHJVARUxXO0wc+QWl2uNLAM0kSEwPjoSfIj4Y7yeoeJzbHSx4/LfednzofVVbd1tat157rt6xKZr36FbWnknqlGN6JHkzVEYpeJ3+xls3VG2bvR0ZDY5MVG17zYokEAAAQAhJs1kl8sGMOFENhlo4qGlfg8260wja5xn8djQ3xXhAiK1UMqElbanpBE0YA0ckgeY8PjL7cbSeySmn4QiraoLXWDXH1+vrzGjby0OxrwYiCQQAABBCMjF7YOi5v5BXW6pgMNNsioTGXNPTYBcZ/HZsorrTDQPNpqcjo6HR8JUQQyM5JUxa0uYloq+9cP2sxw/41RZLIuoWi/q55qzV07dv3/pKZPuZmV2ueq+hcb9C9Hdu21a1bTYjkkAAAAAhJBM2qyx++hfyqGYHK6gEes8ZqyLZRzNrm2fwW7qDIe46MsmiCdJKDYzk1NORUcJPSl930XH6y6tPm348qMTrIOnact575jHTtyciHGR5YCSnrmyqqj92JP3u1MF4Q3FFEggAACCEuVPE7/jZIUlSd1s0828Es4NJdLUoJptKyKz4NNijOZJAiLdsOqnBkZzGQ84QNjg8od45FRpjBV0wh3OTSidtVvdVtJ4oZwgbGplQb5Vnlws+PYeqMC5WM+OsBAAACCGVnBkTaGgkp9se2a2OTHL6F/JqC2bjkaQVXdlI9tHMzExtqWTxMYEm8mqjMgEx1p5O6KFdg7rypvtDbWdgOHdEErp/6cxshUPDE4y/1cI6/ffR8ckIK4GGc1WvqD1llTeodWc23pOkkwQCAAAIIWGmST8J9LODY5KkD1+wfr5VQlm3vFP/9Gtn6+sfPVdLGRi6qFRyJiaFxibyak9z+Yv4CirhwnaHGfS7gxV644blutLvojowkqPqroXdc/1FkhS6omw+gyPVnwHzQ29cp45MUuuWd1Z1u82GT0EAAIAQCgeGDsYDOnt9X2T7MzOdd9xynbEmun00u1Ri9oxtAcYEQtxVq3tWqSqNM9d570tDIzkGYW9hy7uySiet6SqBEgnTBRuWT08/H1fxroMCAAAIKZkwbX1pSGf98b9NT5fLWD31lUwkilYCjebydFFBrFlBL9WHdg3ozLWVJ5PvfPJVvX5ovGiVRpBkHRjOqY3ZC1taNpWcnm0rCoPDR1abVUNfZ0aPvDhU9e02EyqBAAAAQkiaaSSX1+uHxrVlU79+860btOGo7no3K9ZSCVM+PzsJ5JzTgdEJLWXKasTYdRcdpxPe4L0/bX9lcV3CHto1KEl67+YjZycMkkCvHRznXGtx2VQisu5g45N5Defy6qvywNCS1J5OzRrEPI5IAgEAAISQLBgA+oZLT9RvXXz8rPtQe8nEkWMCjU7kNT45Fckvy0CzOHlVj27/9fMlSWOL7MozOJzTqt52rV/RdcRjQReww+OTVZ/ZCY3FSwJFUwk0NDIhSVUfE0iSMqmEchF2Y2sGJIEAAABCKEz40NWoMXgzts2+yH/sZa/8P4pfloFmkk15XwFHc4urhhgYyam3RDK1rWDg9VLLoDVk08nIkkAP7RqQpKqPCST5SaD8lFyU89s3OJJAAAAAIQRJILOZL1eor2KVQNtfOShJ2ti/tB5NAhpGImHKphKL7hIzODJRskLjuBUzXWGjqOJA48imEhqPqFvVMz87JEnatKr679eZpPeZPZEnCQQAAIBFSPgjrbankzKjG1gjKDY72MBITumk6aSVS+rUKqBxtGeSGl1sEmg4p76O4hV1SzvSOnpJVlI0VRxoHFm/oiYKAyM59XVmtKq3o+rbzvg/1kTV9mZAEggAACCElF8JlKEKqGEUmx0smGmGRB3gfYF/5MXBRa07OJybt8on6GVDJVBri3J2sJ/s3K+eEonGsDJJ77N6IsbjAnG1AgAAEELQHWyx42ug+opWAg3nqEwAfKO5vHbtG654vfyU06HxybJm/uqN6Es8GkM2Hc3sYM45vbBvOLLBm9NUApEEAgAACCPhJ4F+6ezVdW4JAsXGBBoamWC2IsB3zTlrNJzLa2qqsnFRgi5knZnUgstSCdTaopodLBir572bj6n6tqWZSqA4zxBGEggAACCEoKT8qO62OrcEAa8SaOYCf8/QqF47NKY+vpQCkqTlXd64PQfHJipaL6h4LJwFbK6gxyWzg7W2bMqbHWwkN1nVhMp0ojG7cKJxMRgTiCQQAABAKB0Zb1r4YDBU1F8yYZr0f01+eWBE5332h3px/wiJOsDX51fFDQznKlovmFGsLZ0sucx5xy6XRHewVpdNJTSay2vj79+lq26+v2rbnXmNRZOqCGbxjGo8o2YQTXoNAAAgJm649ERt2dSvC45fXu+mwJdK2vQF/u7BUUnSb198vH75nDX1bBbQMIIqncGRCiuB/C/o7ZnSSaA//cVNuvbC9eqhEqilLe1I68Co9/p59KWhqm03qDZrnyfRGMbSdu91OTRaWQK0lZAEAgAACGFZV1Zv23h0vZuBAt7sYN4XicER70L/4o1HM0YJ4Au6Rg5WWAlUzhf0tnRSJ/YvWXzj0BT6OjI6PD5Z9e1OJxojSgIFY8MNDleWAG0ldAcDAABAS0klTJP+mEC/980nJYnxgIACQSXQwEhlSaAf79wnKbov6GgeUSXVP/h3D0qS2uapNgujb5Gv/VZCEggAAAAtpSub0qGxSTnnNDCc01HdWR3VzZhNQGCxlUCHxrzKj9NW91a9TWguUQz8PZrL67WD41rantZZa/uqvn1ppivjWK7609s3C5JAAAAAaCl9nRkNDud00P/Ceu2F62XBlEUA1JFJKpNKVDwm0NhEXkvb0/OOCYR4CLpVVVNQnfOpLScwO1iESAIBAACgpfR2ZHRwbFIfu3Xr9N8AZpiZetrTuume5/Sjp18ve73RXJ6uYJAUTRfbh14YkBTte3Ym6c8OVsVp7ZsNSSAAAAC0lPOPW6YT3tCt3YOj2rRyqU5b3VPvJgEN57LTVkqS/vGBF8teZ3QiTxUQJElL2mYqgaqVGHzmtUOSpE2rllZle8WYmdJJ00SMK4GYHQwAAAAtZfPaPt35sQvr3QygoX1qy4navufA9Ax65RidyKuNSiBoduJnfDKv/JRTMhGu2+3gSE4rurPqX9oetnnzyiQTylEJBAAAAACIk96OTNnjAu07PK4fPPWa2tN8hYRmVYRNOWnP0Gio7T39s4P65wdfVm9H9ccamiuTSsS6EogzGAAAAABiqKcjraEyK4H+/r5dkqTVfR0RtgjNIpuanUq4e0f5Y0sVc+Md2yVJG47uDrWdcqSpBAIAAAAAxE1HJqWxifK+DO89NK62dEJffO+pEbcKzWDujIsHRiubaW6uvYfGdc76Pn3pqtNCbaccmVSC2cEAAAAAAPHSlk5qdCKvF/YNyzknSTo4NvvLfH7Kaefrh7R7cFRrl3UqEXLcF7SejkxSLw2MLHr93YMj2j+c03FHdYUeV6gcmWRC+w+XPxZWqyEJBAAAAAAxFAzue9EX7tbtW1/R/3/8VZ184/f15CsHppe5+d7n9bYv3qsf79yno5a01aupaFBL29PqyKT0zcf2LGr9J3Yf0Bs/9yMNjUzo6O7avL4mp5zueWZvTfbViJgdDAAAAABiqHCQ55cGRrR70Bvcd/ueAzpp5VL//mEtbU/rTy7fpFOOiW7qbjSfe37nzepuS+uT33hcP3z6dTnnjugmtpCggugP3rlRV5yxKopmHuGklUv0SsiBrJsZlUAAAAAAEEOFMzwNDhfvHjM4PKGjl2R16cn9WtXLoNCYsWZZp/o6Mzr1mF5N5J1GJ/IVb2PQH5j80k396m6LfmYwSTpuRZfyU266C2TcUAkEAAAAADHUlp5JAv39/S9O3/70t5/S5+/cIckbI+j01b01bxuaR1+nl7wZHJlQR2bhFMPUlNMVN92nF/ePTCeOejoykbaxUNZ/3efyU8qmkgss3XpIAgEAAABADC1pP7Lywky6/PSVs+77hZ9/Q62ahCbU6ydwBodzWtnTvuDyQ6MTevSlIZ21rk/HH92lY1d0KZOqXSelYHr78UmSQAAAAACAmOgtUn2x7Q/eriU16paD1tDX6b2OBkp0KZwrWO6as1fr3aeuXGDp6ptOAk1MSTEc65wkEAAAAADEUF+RJFB3lq+IqEzQlSsY32c+214e0he+73U1DJJHtRZU/4xPVj6GUSvgDAcAAACAGOrtnKn4uel9p+vuHXsrnt0JCJI5pQYXL3T71ld033P7dcoxPTqxf0nUTSsqm57pDhZHJIEAAAAAIIa6Cqp+LjmpX5ec1F/H1qBZLW1Py0waGJlYcNmB4ZyO6W3Xt647vwYtK25Wd7AYIgkEAAAAADFE1Q+qIZkw9bSn9eAL+/XV+3fNu+xPXz2o3jp1AwvQHQwAAAAAEEuZVEKb1zAFPMLZcFS3Hnh+QA88P7DgsleesaoGLSotqATK0R0MAAAAABAnOz5zCRVBCO1rHz5bB0YX7g4mFR+QvJYYEwgAAAAAEEskgFAN6WRCy7uy9W5GWWa6g8UzCZSodwMAAAAAAABqYXpg6JiOCUQSCAAAAAAAxMJ0JVBMZwcjCQQAAAAAAGIh7mMClZUEMrNLzGyHme00s08UedzM7Ev+44+b2enVbyoAAAAAAMDiBd3BxiZmuoM98Px+nfGZH2jrS4P1albNLJgEMrOkpC9LeoekjZKuNrONcxZ7h6QN/r9rJf11ldsJAAAAAAAQSmfWmx/r0Njk9H37D+e0fzinjkzrz51VBfU4bAAADclJREFUTiXQWZJ2Oueed87lJN0q6d1zlnm3pH9wngck9ZhZf5XbCgAAAAAAsGjpZEJL2lIaHMlN3zfg3+7tTNerWTVTTpprpaSXC/7eLensMpZZKenVUK0DAAAAAACoor7OjH7w1Gvae3hckvTc64clSb0dmXo2qybKqQSyIve5RSwjM7vWzB42s4f37t1bTvsAAAAAAACqZsumfrWlE3r61YN6+tWDmshP6dKT+5VOtv7cWeVUAu2WdEzB36sk7VnEMnLO3SzpZknavHnzEUkiAAAAAACAKF1/yQm6/pIT6t2MuignzfWQpA1mts7MMpKuknTHnGXukPR+f5awcyQdcM7RFQwAAAAAAKBBLFgJ5JybNLP/IekuSUlJX3HObTezj/iP3yTpu5K2SNopaUTSr0TXZAAAAAAAAFSqrPnPnHPflZfoKbzvpoLbTtJ11W0aAAAAAAAAqqX1Rz0CAAAAAAAASSAAAAAAAIA4IAkEAAAAAAAQAySBAAAAAAAAYoAkEAAAAAAAQAyQBAIAAAAAAIgBkkAAAAAAAAAxQBIIAAAAAAAgBkgCAQAAAAAAxABJIAAAAAAAgBggCQQAAAAAABADJIEAAAAAAABigCQQAAAAAABADJAEAgAAAAAAiAGSQAAAAAAAADFAEggAAAAAACAGSAIBAAAAAADEAEkgAAAAAACAGCAJBAAAAAAAEAMkgQAAAAAAAGLAnHP12bHZXkkv1mXn1bdc0r56NwI1R9zjibjHDzGPJ+IeT8Q9noh7PBH3eIpL3Nc451YUe6BuSaBWYmYPO+c217sdqC3iHk/EPX6IeTwR93gi7vFE3OOJuMcTcac7GAAAAAAAQCyQBAIAAAAAAIgBkkDVcXO9G4C6IO7xRNzjh5jHE3GPJ+IeT8Q9noh7PMU+7owJBAAAAAAAEANUAgEAAAAAAMSBc66m/yQdI+lHkn4qabuk3yx4rE/SDyQ96//f69+/zF/nsKS/mrO9jLySrmckPS3pPSX2e4akJyTtlPQlzVRB/bmkx/x/z0gaKrH+b0t6StLjkv5d3pRrwWOrJX3fP6anJK0tsn7RY/Mf+6Tfrh2SfqHE/uu6fozj/hF//cck/VjSxoLH7pQ0JOk78xx3qWNbK2m0oA03EfeaxH21v+2t8s7lLSXWz0r6F3/9/1TBOS0pXxC3O0qsf6V/vFOSNs95rKXP9yaO+YWSHpU0KemKOY99wG/zs5I+UEnMxbnezHEv51z/M799j0u6XVJPXM71Jo/7fNd0YT7bSx4bcW/4uIe9lj9Z0v3+8/GEpDbi3jBxD3stX+rznfO9PnFfI+/8fVzS3ZJWlVg/ymv5pj/fq/5CKeOF1C/pdP92t/8C2Oj//XlJn/Bvf0LS5/zbnZLeKO8knvtC+kNJf+TfTkhaXmK/D0o6V5JJ+p6kdxRZ5n9K+kqJ9S+S1OHf/qikfyl47G5JF/u3u4Ll5qxf6tg2Strmv1DXSXpOUrLR1o9x3JcU3H6XpDsL/n6rpHdq/g+OUse2VtKTZTxvxL2KcZf3ofPRgudgV4n1f13+l3VJV2n2+X64jOM+UdLPyXtvKLxgaPnzvYljvlbeh/o/qCAZIO9D+Hn//17/dm+R9UvFfK0415su7hWc62+XlPJvf67WcSPui477fNd0YT7bSx4bcW/4uN+txV/Lp+R9IT3F/3tZFHEj7ouOe9hr+VKf75zv9Yn7bfJ/kJP0FklfLbF+VNfyLXG+V/VFssgX1rc086a7Q1J/wQtux5xlP1jkhfSypM4yXrxPF/x9taS/KbLcfUFbFtjeaZJ+UhCIH5exTtFjk5fJ+2TBcndJOrfR1ifu0+t/b859b9b8Hxylnve1Ku+LIXGvYtwl/Y2k3/VvnyvpvhLbmH4+5L3Z79PMLxALfnAUbOduzf7giN353iwxL1j3Fs1OAs163/C3d3UFMV8rzvWmi7t/X9nnur/85ZK+Vsu4EfdwcfeXm76mK7jvzVrEZ/t8x0bcGzfuCn8tv0XSP4ZYn7jXLu4VX8sXLHe35lSElDo24h5p3LfLr/6RlyA6WGIbUV3Lt8T5Xtcxgcxsrbw34f/07zraOfeqJPn/H7XA+j3+zc+Y2aNmdpuZHV1k0ZWSdhf8vdu/r3Bba+Rl035YRtM/JC8jKUnHSxoys2+Y2VYz+zMzSxZZp9SxrZR3MhzRNjP7WzPbXK/1o9JscTez68zsOXkZ2d+Yr21FzHds6/zXzD1mdkHB/oh78fWrEfcbJb3PzHZL+q68KrBipp8f59ykpAPyMv2S1GZmD5vZA2Z22Xxtnm+7c9vWinFvspiXUo3njHO9+eIuVX6u/6pmrg1ida777Vqr5ox74TVduSo6Nom4z7N+I8Q97LX88ZKcmd3lH8P1BcdH3IuvX9O4h7yWrxhxL7l+NeK+TdJ7/NuXS+o2s2U6UlTX8i1xvtctCWRmXZK+LuljzrmDi9xMStIqeZn80+X1zftCsd0Vuc/N+fsqSf/qnMvPt0Mze5+kzfLGAQjacIGkj0s6U9J6eVnPcpVsm3Pu15xzD9dr/Sg0Y9ydc192zh0r6Xcl/d7imnyEVyWtds6dJq+P+j+Z2RJ/f8S9uGrE/WpJtzjnVsnL5H/VzIq9D863jdXOuc2SfknSX5jZsRUcQ2zO9yaMeSlhnzPO9co1QtylCs51M7tB3rhCX1uobcS9pJrHvcg1XWSIe0mNEPew1/IpeV1frvH/v9zM3ioR93nUNO4RXcuXRNxLqkbcPy7pTWa2VdKbJL0i7/O3km2EuZZvifO9LkkgM0vLexF9zTn3jYKHXjOzfn+ZfkmvL7Cp/ZJG5A3GKHl9BE83s6SZPeb/+7S8DNmqgvVWSdozZ1tXSfrngjb+cbCNgvveJukGSe9yzo37d++WtNU597yfZfympNOLtLXUse2WN+DWfG1rhPVDa9a4F7hVUqXZ4qLH5pwbd87t928/Iq8/5/Hlri/iLi0u7h+S9P8kyTl3v6Q2ScuLxH36+TGzlKSlkgb89fb4/z8vr0T0tHKfC8XkfG/SmJcS6jnjXJ+3baU0QtzLPtfN7AOS/ruka5xzwYVYLM51f79NGfcS13TlqvTYyl2fuNcn7tW4lr/HObfPOTciryqlEb8LhNascS+wmGv5sIj7jNBxd87tcc79ov/j2g3+fQdqfC3f9Od7zZNAZmaS/q+knzrnvjjn4TvkzcIi//9vzbct/2Lr2/L6ckre4F5POefyzrlT/X+/75dQHTKzc/z9v79w22b2c/IG/Ly/YNs3BNvwlzlNXt/TdznnCl/gD0nqNbMV/t9vkTerwFylju0OSVeZWdbM1knaIG8grEZbP5QmjvuGgl1fKm+E9koUPTYzW2F+qbGZrZf3vD9f7voi7tLi4v6Sv57M7ER5Fwx758Z9TtuukPRD55wzs14zy/rrL5d0voqf76W0/PnexDEv5S5Jb/dj3ytvIOC7FlhnGuf6vG0rqhHiXu65bmaXyPtl+V3+xWDhMbf0uS41b9znuaYrV0XHVsH6xL0+cQ97LX+XpJPNrMP/svmmCtcn7tHGPey1fFjE3VeNuJvZcpup+PqkpK/4267VtXxrnO8u4sGj5v6TVzbl5I2qHUzNtsV/bJm8Kd+e9f/vK1hvl7zs3WF5GbBgVPI1ku7VzHSPq0vsd7OkJ+X9CvtXkjcwlP/YjZI+u0C7/03SayoynZyki/39PyFvcMlMkfXnO7Yb/HbtUMHsVZL+Vv5AVPVYn7g7Sfrf8gYge0zeVIc/X/DYf0jaK2/6590qMkVfqWOT15d1u7x+rY9Keidxjz7u8gZ//In/vD8m6e0l1m+T9+vETnlvrOv9+8+Td55v8///UIn1L/fbPS7vfeOuuJzvTRzzM/39Dsv7pWp7wWO/6r8Wdkr6lUpiLs71poy7yj/Xd8rrmx8c801xOdebPO7zXdMt+rN9gWMj7o0d97DX8u+T917/pKTPc743VNzDXsvPd01X6tiIe3Rxv8Lf3zP+85QtsX6U1/JNf74HTyYAAAAAAABaWF1nBwMAAAAAAEBtkAQCAAAAAACIAZJAAAAAAAAAMUASCAAAAAAAIAZIAgEAAAAAAMQASSAAAABJZnajmX18nscvM7ONtWwTAABANZEEAgAAKM9lkkgCAQCApmXOuXq3AQAAoC7M7AZJ75f0sqS9kh6RdEDStZIyknZK+mVJp0r6jv/YAUnv8TfxZUkrJI1I+rBz7ulath8AAKASJIEAAEAsmdkZkm6RdLaklKRHJd0k6e+cc/v9Zf5I0mvOub80s1skfcc596/+Y/8u6SPOuWfN7GxJf+qce0vtjwQAAKA8qXo3AAAAoE4ukHS7c25EkszsDv/+k/zkT4+kLkl3zV3RzLoknSfpNjML7s5G3mIAAIAQSAIBAIA4K1YSfYuky5xz28zsg5LeXGSZhKQh59yp0TUNAACguhgYGgAAxNW9ki43s3Yz65b0Tv/+bkmvmlla0jUFyx/yH5Nz7qCkF8zsSkkyzym1azoAAEDlGBMIAADEVsHA0C9K2i3pKUnDkq7373tCUrdz7oNmdr6k/yNpXNIVkqYk/bWkfklpSbc65z5d84MAAAAoE0kgAAAAAACAGKA7GAAAAAAAQAyQBAIAAAAAAIgBkkAAAAAAAAAxQBIIAAAAAAAgBkgCAQAAAAAAxABJIAAAAAAAgBggCQQAAAAAABADJIEAAAAAAABi4L8AB43sHVGqb8MAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "use_gcn=False\n",
    "no_gcn_train = start_train('宝琳珠宝交易中心', '2016-07-26', '2016-09-06')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "use_gcn=True\n",
    "no_gcn_train = start_train('宝琳珠宝交易中心', '2016-07-26', '2016-09-06')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
